L'ennesimo blog su Ubuntu

Integrare le applicazioni GTK+ in KDE

2011-12-21T16:00:00.000+01:00

Le applicazioni scritte con il toolkit GTK+ (come praticamente tutte le applicazioni dell'ambiente desktop GNOME) non sono nativamente ben integrate nell'ambiente desktop KDE (che invece si basa sul toolkit Qt).

Il toolkit GTK+ permette di impostare un tema per tutte le applicazioni che lo utilizzano, quindi per migliorare l'aspetto di queste applicazioni all'interno di KDE abbiamo bisogno di un tema che assomigli il più possibile al tema in uso su KDE. Esistono diversi temi GTK+ che ben si integrano con le applicazioni Qt, come QtCurve, però in particolare segnalo l'esistenza del tema Oxygen-gtk che è una traduzione in GTK+ del tema predefinito di KDE, cioè Oxygen. Non è scopo di questa guida spiegare come si installano in generale i temi GTK+, vedremo solo come si installa Oxygen-gtk su Debian e sistemi derivati e come fare per utilizzarlo. Sugli altri sistemi operativi (Fedora, openSUSE, Gentoo, Arch Linux, eccetera) potranno cambiare i nomi dei pacchetti da installare e il gestore pacchetti da usare, ma le operazioni da eseguire saranno grosso modo le stesse.

È possibile installare Oxygen-gtk scaricandolo da qui e seguendo le istruzioni riportate nella pagina oppure, su Debian e derivate, installando il pacchetto gtk2-engines-oxygen tramite il gestore pacchetti Synaptic o sul terminale con il comando

sudo apt-get install gtk2-engines-oxygen

Ora dobbiamo solo impostare questo tema come quello utilizzato dalle applicazioni GTK+. Esiste una procedura manuale ben descritta in questa guida (in inglese) del wiki di Arch Linux, ma esiste anche una procedura automatica basata sull'utilizzo di un'apposita interfaccia grafica. Ci sono diversi semplici programmi che permettono di selezionare il tema GTK+ fra i quali gtk-chtheme e lxappearance, ma dal momento che stiamo parlando dell'ambiente desktop KDE suggerisco di utilizzare il selettore dei temi GTK che fa parte degli strumenti di sistema di KDE. Per installarlo su Debian e derivate bisogna installare il pacchetto kde-config-gtk-style con Synaptic oppure via terminale con il comando

sudo apt-get install kde-config-gtk-style

Si può adesso selezionare il tema in Impostazioni di sistema, scegliendo Aspetto delle applicazioni e impostando nella scheda Aspetto GTK lo stile oxygen-gtk.

Manca solo un'ultima operazione prima di finire. Scegliendo lo stile con il programma Impostazioni di sistema abbiamo creato un file nascosto il cui percorso è ~/.gtkrc-2.0-kde (ricordo che la tilde ~ è un'abbreviazione del percorso della home dell'utente corrente), ma per rendere efficace questa impostazione il file deve chiamarsi ~/.gtkrc-2.0 quindi dobbiamo rinominare il file ~/.gtkrc-2.0-kde in ~/.gtkrc-2.0, oppure copiare ~/.gtkrc-2.0-kde e incollarlo con il nuovo nome ~/.gtkrc-2.0 oppure creare un link simbolico ~/.gtkrc-2.0 che punta a ~/.gtkrc-2.0-kde. Per visualizzare i file nascosti in Dolphin bisogna premere la scorciatoia da tastiera ALT + . oppure queste operazioni possono essere eseguite da terminale rispettivamente con i seguenti comandi (basta eseguirne solo uno, quello che si preferisce!):

mv ~/.gtkrc-2.0-kde ~/.gtkrc-2.0 # per rinominare il file
cp ~/.gtkrc-2.0-kde ~/.gtkrc-2.0 # per copiare il file
ln -s ~/.gtkrc-2.0-kde ~/.gtkrc-2.0 # per creare il link simbolico

Adesso tutte le applicazioni GTK che verranno aperte risulteranno finalmente ben integrate con le applicazioni Qt di KDE.

Un'ultima osservazione: l'impostazione del tema GTK viene letta solo dai programmi eseguiti dall'utente nella cui cartella home si trova il file .gtkrc-2.0, ciò permette agli utenti di uno stesso sistema di usare diversi temi. Questo vale anche per l'utente "root", pertanto se si vuole che anche le applicazioni eseguite come utente "root" utilizzino il tema scelto bisogna inserire nella home dell'utente "root" il file .gtkrc-2.0. Per fare questo possiamo copiare il file nella home di "root" oppure creare all'interno di questa un link simbolico al nostro file .gtkrc-2.0 in modo che tutte le modifiche apportate al nostro file .gtkrc-2.0 valgano automaticamente anche per l'utente "root" senza dover modificare ulteriormente suoi file. Da terminale queste due operazioni possono essere eseguite con i comandi (di nuovo, va usato solo uno di questi comandi, quello che si preferisce)

sudo cp ~/.gtkrc-2.0 ~root/.gtkrc-2.0 # per copiare il file
sudo ln -s ~/.gtkrc-2.0 ~root/.gtkrc-2.0 # per creare il link simbolico

Per quanto ne so al momento il tema Oxygen-gtk funziona solo con le applicazioni che utilizzano la versione 2 del toolkit GTK+, per essere più precisi non mi risulta che sia facile utilizzare in maniera semplice questo tema anche con le applicazioni che utilizzano GTK+ 3. Sono ben accetti suggerimenti in questa direzione

Compilare moduli del kernel con DKMS

2011-08-11T16:59:00.000+02:00

Il Dynamic Kernel Module Support (DKMS) è un sistema che permette di generare moduli per il kernel Linux i quali non sono presenti nel sorgente del kernel stesso. Quando viene installata una nuova versione del kernel Linux, normalmente è necessario ricompilare questi moduli. Nei sistemi Debian e derivati (e probabilmente anche in altre distribuzioni con kernel Linux), questa operazione viene svolta automaticamente eseguendo lo script /usr/lib/dkms/dkms_autoinstaller. A volte, però, si potrebbe voler ricompilare manualmente un modulo, oppure compilarlo per una versione del kernel diversa da quella per cui esiste già. La sintassi da usare per ricompilare un modulo chiamato <modulo> è la seguente

sudo dkms build -m <modulo> -v <versione_modulo> -k <versione_kernel>

sudo dkms install -m <modulo> -v <versione_modulo> -k <versione_kernel>

sudo dkms status

Il primo comando serve per compilare il modulo, nella versione <versione_modulo> e per il kernel <versione_kernel>, il secondo comando serve per installare il modulo compilato (prima di procedere con questo comando assicurarsi che la compilazione sia andata a buon fine. La buona riuscita o meno della compilazione viene segnalata dai messaggi di output del comando dkms build) e l'ultimo serve per verificare lo stato dei moduli gestiti da DKMS, per controllare che i moduli desiderati siano stati effettivamente installati. Per conoscere la versione del kernel attualmente in uso si può dare nel terminale il comando uname -r.

Quando si installa una nuova versione dei driver proprietari della scheda video (farò l'esempio con una scheda Nvidia), viene compilato solo il modulo per il kernel attualmente in uso (oltre ai kernel successivamente installati, come abbiamo già detto prima). Si potrebbe, però, voler compilare il modulo anche per una versione del kernel diversa da quella in uso (come può essere una versione precedente). Ammettiamo quindi per esempio che il modulo che si voglia ricompilare è il driver Nvidia, chiamato nvidia, che la sua versione è la 280.13 e che il kernel per il quale si vuole ricompilare il modulo è il 3.0.0-1-686-pae. Dunque dovremo dare i seguenti comandi per compilare e installare il modulo:

sudo dkms build -m nvidia -v 280.13 -k 3.0.0-1-686-pae

sudo dkms install -m nvidia -v 280.13 -k 3.0.0-1-686-pae

Alla fine potremo usare il comando dkms status per controllare lo stato dei moduli così installati. L'output sarà qualcosa di questo tipo

nvidia, 280.13, 2.6.38-2-686, i686: installed

nvidia, 280.13, 2.6.39-2-686-pae, i686: installed

nvidia, 280.13, 3.0.0-1-686-pae, i686: installed

Naturalmente consiglio di consultare il manuale di DKMS (man dkms) per avere maggiori informazioni sul programma e le sue opzioni.

Invece di usare dkms build e dkms install, è possibile utilizzare il comando dkms autoinstall che installa, per una specifica versione del kernel, tutti i moduli che sono già installati per altre versioni del kernel diverse da quella indicata. La sintassi è

sudo dkms autoinstall --kernelver <versione_kernel>

Si può anche eseguire direttamente lo script dkms_autoinstaller citato all'inizio (il breve script dkms_autoinstaller richiama a sua volta dkms autoinstall al suo interno). La sintassi è

/usr/lib/dkms/dkms_autoinstaller start

se si vogliono compilare i moduli per il kernel attualmente in uso oppure

/usr/lib/dkms/dkms_autoinstaller start <versione_kernel>

se si vuole indicare una particolare versione del kernel.

I comandi sopra spiegati sono validi solo se il modulo è già predisposto per la compilazione con DKMS. Per aggiungere il supporto a DKMS a dei moduli di cui si possiede il codice sorgente si può vedere qui.

I comandi di questo post sono stati presi dal seguente messaggio dell'utente bugsbunny sul forum forums.debian.net: http://forums.debian.net/viewtopic.php?f=6&t=66973#p382913.

Conflitto fra i moduli delle schede audio

2011-06-26T15:28:00.002+02:00

Sul mio vecchio muletto ho due schede audio, una integrata e una esterna. Questo è la parte dell'output del comando lspci -v che riguarda le mie due schede audio

00:02.7 Multimedia audio controller: Silicon Integrated Systems [SiS] AC'97 Sound Controller (rev a0)
        Subsystem: C-Media Electronics Inc CMI9739(A) on ECS K7SOM+ motherboard
        Flags: bus master, medium devsel, latency 64, IRQ 11
        I/O ports at d800 [size=256]
        I/O ports at d400 [size=64]
        Capabilities: <access denied>
        Kernel modules: snd-intel8x0

00:11.0 Multimedia audio controller: Creative Labs SB Live! EMU10k1 (rev 08)
        Subsystem: Creative Labs SBLive! 5.1 Model SB0100
        Flags: bus master, medium devsel, latency 64, IRQ 11
        I/O ports at d000 [size=32]
        Capabilities: <access denied>
        Kernel driver in use: EMU10K1_Audigy
        Kernel modules: snd-emu10k1

La scheda integrata è la prima (e segue lo standard AC'97), la seconda è la scheda esterna. Le casse audio sono collegate alla scheda esterna e su Windows (mi duole ammetterlo) l'audio funziona senza problemi, mentre su Ubuntu non sentivo nulla fino a qualche minuto fa (in realtà l'audio funzionava prima di aggiornare Ubuntu alla versione 9.10 Karmic Koala). Ho impiegato più di un anno e mezzo per capire quale fosse il problema ma l'importante è arrivarci (e da solo!): facevano conflitto i driver (o "moduli") delle due schede (anche se non so perché con le precedenti versioni di Ubuntu questo problema non si presentasse). I nomi dei moduli del kernel utilizzati dalle due schede possono essere letti nell'output del comando lspci -v: snd-intel8x0 per la scheda integrata (cioè quella che non uso) e snd-emu10k1 per la scheda esterna.

Per mettere in blacklist un modulo del kernel chiamato modulo bisogna mettere in un file con estensione .conf della cartella /etc/modprobe.d la riga

blacklist modulo

Dunque per far tornare magicamente l'audio sul mio computer ho dato il seguente comando da terminale

echo "blacklist snd_intel8x0" | sudo tee /etc/modprobe.d/blacklist-audio.conf

È possibile aggiungere un commento, per ricordarsi perché si è aggiunto un modulo alla blacklist, facendo iniziare le righe di commento con #. Per esempio ho modificato il file appena creato (con i diritti di amministratore perché si trova sotto /etc) aggiungendo il seguente commento

# Metto il modulo della scheda audio integrata nella blacklist per
# evitare che entri in conflitto con quello della scheda esterna
blacklist snd_intel8x0

Schermo nero al ritorno dalla sospensione

2011-04-24T21:01:00.001+02:00

Dopo aver aggiornato il kernel Linux alla versione 2.6.38 (ma non sono sicuro che sia questa particolare versione del kernel la causa del problema) al ritorno dalla sospensione trovo lo schermo nero senza la possibilità di fare nulla. In realtà basta premere ALT + CTRL + F7 (o altro tasto funzione associato alla console in cui è avviato il server grafico X.org) per far comparire la la schermata per l'inserimento della password e tornare a utilizzare il proprio computer. Nel file di log /var/log/pm-suspend.log in corrispondenza del ritorno dalla sospensione compare qualcosa del tipo:

/usr/lib/pm-utils/sleep.d/99video suspend suspend: success.
Sun Apr 24 17:17:00 CEST 2011: performing suspend
Sun Apr 24 17:18:39 CEST 2011: Awake.
Sun Apr 24 17:18:39 CEST 2011: Running hooks for resume
Running hook /usr/lib/pm-utils/sleep.d/99video resume suspend:
Couldn't get a file descriptor referring to the console
VT_DISALLOCATE: Device or resource busy
deallocvt: could not deallocate console 63

Come segnalato qui per risolvere il problema dovrebbe essere sufficiente creare il file /etc/pm/config.d/10no-vt-switch contenente semplicemente

ADD_PARAMETERS=" --quirk-no-chvt "

però non ho provato personalmente questa soluzione. Il problema comunque potrebbe essere molto legato al particolare hardware del computer usato. Quindi controllate se i vostri componenti sono gli stessi di quelli riportati sul Wiki di Debian.

Emacs: effettuare il controllo della sintassi di documenti LaTeX

2011-04-24T20:20:00.023+02:00

Nel post Opzioni utili per comporre documenti LaTeX in GNU Emacs + AUCTeX illustrai le principali opzioni di Emacs che trovo particolarmente utili per scrivere documenti LaTeX. Ora voglio mostrare l'impostazione di uno strumento esterno a AUCTeX ma che ritengo molto utile.

Il pacchetto Flymake, presente di default nelle ultime versioni di GNU Emacs, permette di effettuare un controllo della sintassi al volo, cioè durante la scrittura di un codice. Quindi per trovare un errore formale all'interno di questo non sarà necessario avviare manualmente la compilazione ma sarà Emacs stesso ad avvisare della loro presenza. Per fare questo Flymake si appoggia a programmi esterni di controllo della sintassi. Per quanto riguarda LaTeX esistono almeno un paio di programmi specifici: Lacheck e ChkTeX. Il primo non è più sviluppato dal 1997 e ha difficoltà con macro molto elaborate, quindi molto probabilmente non vorrete utilizzarlo (sebbene sia lo strumento predefinito da Emacs per effettuare l'analisi sintattica, non al volo, che si avvia con C-c C-c Check RET. È possibile cambiare questa impostazione modificando la variabile TeX-command-list come visto prima), il secondo progetto è un po' più attivo. Inoltre per effettuare un controllo della sintassi è possibile anche utilizzare i compilatori stessi latex, pdflatex, ecc., utilizzati con delle opportune opzioni di compilazione che vedremo più avanti.

Volendo usare ChkTex bisogna inserire nel proprio file di inizializzazione ~/.emacs il seguente codice:

(require 'flymake)
(defun flymake-get-tex-args (file-name)
  (list "chktex" (list "-q" "-v0" file-name)))
(add-hook 'LaTeX-mode-hook 'flymake-mode)

Analizziamo nel dettaglio queste istruzioni: la riga (require 'flymake) dice semplicemente a Emacs di caricare il pacchetto flymake; le due successive specificano il programma esterno da usare (nel caso specifico chktex) e i relativi argomenti da passare, nel nostro caso -q -v0 seguiti dal nome del file che si sta modificando contenuto nella variabile file-name. Per capire cosa fanno le varie opzioni consultare il manuale. Infine l'ultima fa in modo che ogni volta che si apre un documento con la major mode LaTeX-mode venga attivata la minor mode flymake-mode. Se non si vuole aggiungere questa ultima funzione sarà necessario attivare manualmente la modalità con M-x flymake-mode.

Penso sia ora chiaro come bisogna modificare il codice precedente per appoggiarsi a uno strumento diverso da ChkTex. Bisogna sostituire a chktex il nome del programma desiderato e inserire al posto di "-q" "-v0" l'eventuale elenco di opzioni volute. Per esempio, volendo usare Lacheck, senza alcuna opzione passata da linea di comando, dovremo inserire

(require 'flymake)
(defun flymake-get-tex-args (file-name)
  (list "lacheck" (list file-name)))
(add-hook 'LaTeX-mode-hook 'flymake-mode)

Come detto, è possibile anche utilizzare il compilatore stesso per effettuare un controllo della sintassi. Infatti quando compiliamo un documento il compilatore ci avvisa della presenza di errori. Tuttavia normalmente l'esecuzione della compilazione viene interrotta al punto in cui viene incontrato un errore, mentre noi vogliamo che tutto il codice sorgente venga analizzato affinché siano riportati tutti gli errori presenti e ciò può essere realizzato passando a pdflatex l'opzione -interaction=nonstopmode. Altre opzioni utili nel nostro caso sono -draftmode, che impedisce la creazione del file di output in PDF velocizzando così l'esecuzione del controllo, e -file-line-error, per fare in modo che Flymake possa effettuare correttamente il parsing dell'output di pdflatex. Dunque per utilizzare pdflatex come strumento di controllo della sintassi dovremo inserire il seguente codice nel nostro file di inizializzazione:

(require 'flymake)
(defun flymake-get-tex-args (file-name)
  (list "pdflatex"
        (list "-file-line-error" "-draftmode" "-interaction=nonstopmode" file-name)))
(add-hook 'LaTeX-mode-hook 'flymake-mode)

Ricordo sempre che si potrebbe non voler inserire l'ultima riga preferendo attivare manualmente la modalità flymake-mode solo nei documenti in cui si desidera effettivamente svolgere l'analisi sintattica.

Una volta attivata la modalità flymake-mode gli errori saranno evidenziati in rosso e passando sul testo incriminato con il mouse oppure usando il comando M-x flymake-display-err-menu-for-current-line verrà mostrata la spiegazione dell'errore segnalato.

Devo evidenziare che pdflatex è piuttosto dispendioso dal punto di vista delle risorse di sistema e inoltre molto lento per i documenti grandi. Facendo delle prove su un documento di circa 200 pagine nel documento di output ChkTex e Lacheck hanno impiegato meno di mezzo secondo per concludere l'analisi dell'intero codice sorgente, contro gli oltre 20 secondi di pdflatex. D'altra parte il programma più affidabile è il compilatore stesso, infatti è l'unico dei tre programmi qui discussi in grado di riconoscere i comandi o pacchetti non esistenti. Se si preferisce la velocità a discapito della precisione allora lo strumento ideale è ChkTex, se invece si vuole un controllo più preciso e mirato allora pdflatex fa al caso vostro (in particolare nei documenti piccoli).

Trovate maggiori informazioni su Flymake sul sito Emacs Wiki alle pagine Fly Make e Flymake Tex (da cui questo post prende ispirazione), oppure nel manuale consultabile dentro Emacs con C-h i d m Flymake RET.

Aggiungere "Monta archivi" in Debian

2011-04-04T23:05:00.001+02:00

Chi ha usato, almeno provato o visto Ubuntu, dalla versione 8.10 in poi, probabilmente avrà notato che facendo clic con il tasto destro sull'icona di un'immagine .iso è possibile scegliere l'opzione «Apri con Monta archivi». Questa opzione permette di montare rapidamente e per via grafica l'immagine che altrimenti potrebbe essere montata su un terminale con un comando di questo tipo

mount -o loop -t iso9660 /percorso/della/immagine.iso /punto/di/mount

in cui bisognerà naturalmente sostituire a /percorso/della/immagine.iso il percorso dell'immagine che si vuole montare e a /punto/di/mount il percorso del punto di mount scelto e precedentemente creato.

È possibile aggiungere l'opzione «Apri con Monta archivi» anche in Debian (dovrebbe funzionare da Lenny in poi, personalmente ho provato su Wheezy testing) semplicemente copiando il lanciatore utilizzato in Ubuntu per aggiungere quell'opzione. Prima di fare ciò bisogna installare, se non già presente, il pacchetto gvfs-backends:

apt-get install gvfs-backends

A questo punto è possibile scaricare il lanciatore dall'indirizzo http://bazaar.launchpad.net/~ubuntu-branches/ubuntu/natty/nautilus/natty/download/head:/mountarchive.desktop-20100222031218-t6ar3c8jxy685cre-2783/mount-archive.desktop (come ottenere questo indirizzo, che potrebbe cambiare in futuro: andare in https://code.launchpad.net/ubuntu/+source/nautilus, selezionare il ramo principale lp:ubuntu/nautilus → Browse the code, reperire il file debian/mount-archive.desktop) e metterlo nella cartella ~/.local/share/applications se si vuole che sia disponibile solo per il proprio utente, altrimenti in /usr/share/applications/ affinché possa essere usato da tutti gli utenti del sistema. Da terminale può essere scaricato con il comando

wget -P ~/.local/share/applications http://bazaar.launchpad.net/~ubuntu-branches/ubuntu/natty/nautilus/natty/download/head:/mountarchive.desktop-20100222031218-t6ar3c8jxy685cre-2783/mount-archive.desktop

nel primo caso, per il secondo:

wget -P /usr/share/applications http://bazaar.launchpad.net/~ubuntu-branches/ubuntu/natty/nautilus/natty/download/head:/mountarchive.desktop-20100222031218-t6ar3c8jxy685cre-2783/mount-archive.desktop

usando i diritti di root per poter scrivere sotto /usr.

È possibile aggiungere nel lanciatore, utilizzando un qualsiasi editor di testo, la riga

Name[it_IT]=Monta archivi

in modo che il nome dell'opzione sia in italiano se il sistema è localizzato in italiano.

Ho detto che questo sistema funziona su Debian, in realtà dovrebbe funzionare su qualsiasi sistema GNU/Linux che abbia il programma gvfsd-archive.

Compilare GNU Octave 3.4.0

2011-02-26T15:41:00.000+01:00

Lo scorso 8 febbraio è stata rilasciata la versione 3.4.0 di GNU Octave, sostituto libero di MATLAB. Trovate le novità di questa versione qui.

In questo post spiegherò come compilare questa versione di GNU Octave. Qualche mese fa avevamo visto come compilare la versione 3.2.2. Non sarà molto diverso compilare la 3.4.0, anzi, personalmente ho incontrato molti meno problemi nel compilare la 3.4.0 rispetto alla 3.2.2. La guida è stata sperimentata su Ubuntu 10.10, non dovrebbero esserci praticamente differenze per compilare GNU Octave su Debian Sid. Per le altre distribuzioni GNU/Linux le uniche cose differenti saranno probabilmente i comandi da usare per richiamare il gestore pacchetti utilizzato.

Per prima cosa installiamo il compilatore installando il metapacchetto build-essential. Questo può essere installato da Synaptic, oppure da terminale con il comando:

sudo apt-get install build-essential

Il metapacchetto build-essential installa i compilatori se non già presenti, se sono già installati... non fa praticamente nulla. In questo modo comunque ci assicuriamo di averli installati. Dopo di ciò installiamo le dipendenze, ovvero le librerie necessarie per la compilazione di GNU Octave. Possiamo fare ciò molto velocemente da terminale con il comando:

sudo apt-get build-dep octave3.2

Questo comando installerà le dipendenze necessarie per compilare il ramo 3.2 di GNU Octave, ma queste sono praticamente identiche a quelle del ramo 3.4. Manca solo una libreria da installare. Non impedisce la compilazione, però potrebbe essere utile in alcuni casi. Si chiama bison e può essere installata come al solito da Synaptic oppure da terminale con il comando

sudo apt-get install bison

Scarichiamo ora il codice sorgente di GNU OCtave: http://www.gnu.org/software/octave/download.html. La versione 3.4.0 può essere scaricata da terminale con il comando

wget ftp://ftp.gnu.org/gnu/octave/octave-3.4.0.tar.bz2

Scompattiamo l'archivio. Lo si può fare per via grafica oppure da terminale con il comando

tar xjvf octave-3.4.0.tar.bz2

Entriamo con il terminale nella cartella principale del codice sorgente di GNU Octave:

cdd octave-3.4.0/

Leggiamo i file README e INSTALL che spiegano come si compila il programma. Per prima cosa dobbiamo configurare il programma usando lo script configure. Potete vedere l'elenco delle opzioni di configurazione possibili richiamando lo script con l'opzione --help:

./configure --help

Possiamo ora configurare GNU Octave:

./configure

Se lo ritenete necessario potete, naturalmente, aggiungere le opzioni che preferite. Se tutto è andato a buon fine dovreste leggere alla fine dell'output di ./configure qualcosa di questo tipo:

Octave is now configured for i686-pc-linux-gnu

  Source directory:            .
  Installation prefix:         /usr/local
  C compiler:                  gcc  -mieee-fp  -Wall -W -Wshadow -Wformat -Wpointer-arith -Wmissing-prototypes -Wstrict-prototypes -Wwrite-strings -Wcast-align -Wcast-qual -g -O2 -pthread
  C++ compiler:                g++  -mieee-fp  -I/usr/include/freetype2    -Wall -W -Wshadow -Wold-style-cast -Wformat -Wpointer-arith -Wwrite-strings -Wcast-align -Wcast-qual -g -O2
  Fortran compiler:            gfortran -O -mieee-fp
  Fortran libraries:            -L/usr/lib/gcc/i686-linux-gnu/4.4.5 -L/usr/lib/gcc/i686-linux-gnu/4.4.5/../../../../lib -L/lib/../lib -L/usr/lib/../lib -L/usr/lib/gcc/i686-linux-gnu/4.4.5/../../.. -L/usr/lib/i686-linux-gnu -lgfortranbegin -lgfortran -lm
  Lex libraries:               
  LIBS:                        -lm  

  AMD CPPFLAGS:                
  AMD LDFLAGS:                 
  AMD libraries:               -lamd
  BLAS libraries:              -lblas
  CAMD CPPFLAGS:               
  CAMD LDFLAGS:                
  CAMD libraries:              -lcamd
  CARBON libraries:            
  CCOLAMD CPPFLAGS:            
  CCOLAMD LDFLAGS:             
  CCOLAMD libraries:           -lccolamd
  CHOLMOD CPPFLAGS:            
  CHOLMOD LDFLAGS:             
  CHOLMOD libraries:           -lcholmod
  COLAMD CPPFLAGS:             
  COLAMD LDFLAGS:              
  COLAMD libraries:            -lcolamd
  CURL CPPFLAGS:               
  CURL LDFLAGS:                
  CURL libraries:              -lcurl
  CXSPARSE CPPFLAGS:           
  CXSPARSE LDFLAGS:            
  CXSPARSE libraries:          -lcxsparse
  DL libraries:                -ldl
  FFTW3 CPPFLAGS:              
  FFTW3 LDFLAGS:               
  FFTW3 libraries:             -lfftw3
  FFTW3F CPPFLAGS:             
  FFTW3F LDFLAGS:              
  FFTW3F libraries:            -lfftw3f
  fontconfig CFLAGS:            
  fontconfig LIBS:             -lfontconfig  
  FT2_CFLAGS:                  -I/usr/include/freetype2
  FT2_LIBS:                    -lfreetype -lz
  GLPK CPPFLAGS:               
  GLPK LDFLAGS:                
  GLPK libraries:              -lglpk
  graphics CFLAGS:             -g -O2 -D_THREAD_SAFE -D_REENTRANT
  graphics LIBS:               -Wl,-Bsymbolic-functions -lfltk_gl -lfltk
  Magick++ CPPFLAGS:           -I/usr/include/GraphicsMagick  
  Magick++ LDFLAGS:             
  Magick++ libraries:          -lGraphicsMagick++ -lGraphicsMagick  
  HDF5 CPPFLAGS:               
  HDF5 LDFLAGS:                
  HDF5 libraries:              -lhdf5
  LAPACK libraries:            -llapack
  OPENGL libraries:            -lfontconfig   -lGL -lGLU
  PTHREAD flags:               -pthread
  PTHREAD libraries:           
  QHULL CPPFLAGS:              
  QHULL LDFLAGS:               
  QHULL libraries:             -lqhull
  QRUPDATE libraries:          -lqrupdate
  READLINE libraries:          -lreadline
  REGEX libraries:             -L/usr/lib -lpcre
  TERM libraries:              -lncurses
  UMFPACK libraries:           -lumfpack
  X11 include flags:           
  X11 libraries:               -lX11
  Z CPPFLAGS:                  
  Z LDFLAGS:                   
  Z libraries:                 -lz

  Default pager:               less
  gnuplot:                     gnuplot

  Do internal array bounds checking:  false
  Build static libraries:             false
  Build shared libraries:             true
  Dynamic Linking:                    true (dlopen)
  Include support for GNU readline:   true
  64-bit array dims and indexing:     false

Se non avessimo installato bison avremmo inoltre letto un avviso di questo tipo:

configure: WARNING: I didn't find bison, but it's only a problem if you need to reconstruct parse.cc
configure: WARNING: OpenGL libs (GL and GLU) not found. Native graphics will be disabled.
configure: WARNING: 
configure: WARNING: I didn't find the necessary libraries to compile native
configure: WARNING: graphics.  It isn't necessary to have native graphics,
configure: WARNING: but you will need to have gnuplot installed or you won't
configure: WARNING: be able to use any of Octave's plotting commands
configure: WARNING: 
configure: 
configure: NOTE: libraries may be skipped if a library is not found OR
configure: NOTE: if the library on your system is missing required features.

Questo è il messaggio che ho ottenuto io dopo la prima configurazione (non avevo però ancora installato bison). Come potete vedere mi è stata segnalata l'assenza delle librerie OpenGL. Ho risolto questo "problema" (non è un vero e proprio problema perché si tratta solo di un avviso, non è un errore) installando i pacchetti libgl1-mesa-dev e libglu1-mesa-dev:

sudo apt-get install libgl1-mesa-dev libglu1-mesa-dev

Normalmente questo problema non dovrebbe verificarsi perché questi pacchetti dovrebbero essere installati usando apt-get build-dep octave3.2, non so bene per quale motivo a me sono stati rimossi.

Dopo aver finalmente configurato GNU Octave possiamo compilarlo con il comando

make

Per rendere più veloce la compilazione, chi ha un processore multicore può passare a make l'opzione -j n, dove n è il numero di core del processore (o meglio di job simultanei che può gestire, però per semplificare il discorso parliamo di core). Quindi chi, per esempio, ha un processore con quattro core potrà usare per compilare GNU Octave il comando

make -j 4

Se la compilazione va a buon fine (a seconda della potenza di calcolo del proprio computer questa operazione può richiedere da poche decine di minuti a qualche ora) alla fine dell'operazione leggerete sul terminale un messaggio di questo tipo:

Octave successfully built.  Now choose from the following:

   ./run-octave    - to run in place to test before installing
   make check      - to run the tests
   make install    - to install (PREFIX=/usr/local)

make[2]: uscita dalla directory "/[...]/octave-3.4.0"
make[1]: uscita dalla directory "/[...]/octave-3.4.0"

Come potete vedere, prima di installare Octave potete avviarlo per verificare se funzioni con il comando

./run-octave

Infine possiamo installarlo con il comando

sudo make install

Se invece vogliamo crare un pacchetto .deb per rendere più semplice la successiva installazione o rimozione possiamo usare checkinstall:

sudo checkinstall

Compilare QtiPlot 0.9.8.4

2011-02-20T01:22:00.008+01:00

NOTA: Renato Rivoira, che ringrazio, ha curato la traduzione in italiano di QtiPlot e del suo manuale. Nei commenti a questo post chiede, a chi sia in grado di farlo, di aiutarlo a revisionare le sue traduzioni. Potete contattarlo mandandogli una mail all'indirizzo renatoriv AT libero PUNTO it.

Il 18 febbraio 2011 è stata rilasciata la versione finale di QtiPlot 0.9.8.4, un programma per l'analisi dei dati, equivalente libero di Origin. Questa versione porta con sé numerose novità che potete leggere qui.

QtiPlot è un programma un po' particolare perché il codice sorgente è rilasciato con licenza GPL ma lo sviluppatore distribuisce i binari precompilati a pagamento. Ciò non è in alcun modo in contrasto con il concetto di software libero perché nella sua definizione non si parla di prezzo. La confusione di "software libero" con "software gratuito" è maggiormente presente nelle persone di lingua inglese, poiché in questa la parola "free" ha il duplice significato di "libero" e "gratuito". Anche chi usa questo software avendolo compilato da sé può fare una donazione a favore del progetto all'indirizzo http://soft.proindependent.com/why_donate.html per permettere allo sviluppatore di portare avanti il suo progetto.

In questo post spiegherò come fare a compilare QtiPlot. Questa guida è per Ubuntu Maverick Meerkat 10.10 (e probabilmente funzionerà senza troppi problemi anche per Debian), per le altre distribuzioni ci potranno essere piccoli differenze per quanto riguarda i comandi che richiamano il gestore dei pacchetti, i nomi dei pacchetti e la disponibilità di questi.

Innanzitutto cominciamo con l'installare tutte le dipendenze necessarie per la compilazione. In un terminale dare

sudo apt-get install build-essential
sudo apt-get build-dep qtiplot

Il primo comando installa (se non già presente, ma è difficile che non lo sia già) le utility necessarie per compilare la maggior parte dei programmi, il secondo installa le principali librerie che necessita QtiPlot per essere compilato. Nelle ultime versioni QtiPlot ha aggiunto altre dipendenze i cui pacchetti non sono disponibili nella versione di Ubuntu considerata, quindi prima di procedere con la compilazione di QtiPlot stesso dovremo compilare altri programmi.

Scarichiamo il codice sorgente di QtiPlot all'indirizzo http://download.berlios.de/qtiplot/qtiplot-0.9.8.4.tar.bz2. Da terminale si può usare

wget http://download.berlios.de/qtiplot/qtiplot-0.9.8.4.tar.bz2

Scompattiamo l'archivio dove ci pare (se non siete in grado di farlo da terminale, vi ricordo che è possibile farlo attraverso interfaccia grafica) e spostiamoci con il terminale nella cartella in cui si trova il sorgente:

tar xjvf qtiplot-0.9.8.4.tar.bz2
cd qtiplot-0.9.8.4/

Aprite il file README.html presente nella cartella del sorgente (è sempre buona norma leggere i file README e/o INSTALL, o simili, prima di procedere con la compilazione di un programma). Come potete vedere le dipendenze necessarie sono le seguenti: Qt (>= 4.5.0), GSL, muParser (1.32), zlib e libpng. Tutti questi pacchetti sono stati installati (se non erano già presenti) con il comando sudo apt-get build-dep qtiplot. Inoltre servono delle versioni leggermente modificate delle librerie Qwt (5.2) e QwtPlot3D, ma queste sono presenti nella sottocartella 3rdparty/ del codice sorgente di QtiPlot, quindi non bisogna scaricare nulla di nuovo per questo elencato finora. Altre librerie suggerite sono QTeXEngine, ALGLIB (2.6) e TAMUANOVA.

Compiliamo queste librerie. Salveremo i codici sorgenti di queste nella sottocartella 3rdparty/, per comodità, quindi spostiamoci in questa cartella:

cd 3rdparty/

Scarichiamo e scompattiamo l'archivio contenente il codice sorgente di QTeXEngine:

wget http://download.berlios.de/qtiplot/QTeXEngine-0.3-opensource.zip
unzip QTeXEngine-0.3-opensource.zip
cd QTeXEngine

Compiliamo la libreria (le istruzioni sono presenti nel file README.txt:

qmake
make

Se tutto è andato bene (lo potete controllare guardando l'exit status con il comando echo $?, se è 0 allora l'operazione si è conclusa correttamente) torniamo nella cartella superiore, scarichiamo il codice sorgente di ALGLIB e compiliamolo:

cd ..
wget http://www.alglib.net/translator/re/alglib-2.6.0.cpp.zip
unzip alglib-2.6.0.cpp.zip ; mv cpp alglib
cd alglib

Le istruzioni per la compilazione di questa libreria sono presenti nel file manual.cpp.html. Bisogna eseguire lo script build passando come argomento il compilatore da usare, nel nostro caso GCC. Lo script build non ha i permessi di esecuzione, quindi prima di avviarlo dobbiamo rendere il file eseguibile:

chmox +x build
./build gcc

Se anche questa operazione si è conclusa con successo (controlliamo l'exit status con echo $?: se otteniamo 0 allora è andato tutto bene) andiamo avanti possiamo compilare TAMUANOVA. Spostiamoci nella cartella superiore, scarichiamo il codice sorgente di TAMUANOVA, scompattiamo l'archivio ed entriamo nella cartella del codice sorgente di questa libreria:

cd ..
wget http://www.stat.tamu.edu/~aredd/tamuanova/tamu_anova-0.2.tar.gz
tar xzvf tamu_anova-0.2.tar.gz ; mv tamu_anova-0.2/ tamu_anova/
cd tamu_anova/

Compiliamo questa libreria (le istruzioni sono presenti nel file INSTALL):

./configure
make

Controllate l'exit status con echo $?. Se ottenete 0 la compilazione è andata a buon fine. Non è necessario installare la libreria (come neanche le precedenti), è sufficiente averla compilata. Prima di procedere dobbiamo modificare un file: 3rdparty/qwtplot3d/qwtplot3d.pro. Questo file contiene le istruzioni per la compilazione della libreria QwtPlot3D (che avverrà successivamente quando compileremo QtiPlot). Alla fine di questo file bisogna aggiungere la seguente riga:

unix:CONFIG += staticlib

affinché venga compilata staticamente (suggerimento tratto da qui).

Ritorniamo con il terminale nella cartella principale del codice sorgente di QtiPlot (che si trova due cartelle superiori rispetto alla carella di ALGLIB in cui ci trovavamo prima):

cd ../..

Prima di iniziare la compilazione vera e propria ci sono ancora diverse operazioni da fare. Prima di tutto dobbiamo creare un file chiamato build.conf da posizionare nella cartella del codice sorgente di QtiPlot e che contiene alcune istruzioni che servono per la compilazione. Questo file dovrà essere realizzato sulla base del modello build.conf.example che si trova nella stessa cartella. Per la precisione, build.conf contiene alcune opzioni e variabili per la compilazione e i percorsi delle librerie da utilizzare (oppure le corrispondenti opzioni di compilazione). In questo file la variabile QTI_ROOT è uguale al percorso della cartella principale del codice sorgente di QtiPlot. Ho modificato build.conf.example in base ai reali percorsi delle librerie utilizzate ed ecco il mio build.conf:

isEmpty( QTI_ROOT ) {
  message( "each file including this config needs to set QTI_ROOT to the dir containing this file!" )
}

##########################################################
##     System specific configuration
##########################################################

# Global include path which is always added at the end of the INCLUDEPATH
SYS_INCLUDEPATH = /opt/local/include
# Global lib path and libs which is ls always added at the end of LIBS
SYS_LIBS = -L/opt/local/lib

##########################################################
## zlib (http://www.zlib.net/)
##########################################################

# include path. leave it blank to use SYS_INCLUDE
ZLIB_INCLUDEPATH = $$QTI_ROOT/3rdparty/zlib/

##########################################################
## muParser (http://muparser.sourceforge.net/)
##########################################################

# include path. leave it blank to use SYS_INCLUDE
MUPARSER_INCLUDEPATH = /usr/include/muParser/
# link statically against a copy in 3rdparty/
MUPARSER_LIBS = /usr/lib/libmuparser.so
# or dynamically against a system-wide installation
# MUPARSER_LIBS = -lmuparser

##########################################################
## GNU Sientific Library (http://www.gnu.org/software/gsl/)
##########################################################

# include path. leave it blank to use SYS_INCLUDE
# GSL_INCLUDEPATH = $$QTI_ROOT/3rdparty/gsl/include
# link statically against a copy in 3rdparty/
# GSL_LIBS = $$QTI_ROOT/3rdparty/gsl/lib/libgsl.a \
#            $$QTI_ROOT/3rdparty/gsl/lib/libgslcblas.a
# or dynamically against a system-wide installation
GSL_LIBS = -lgsl -lgslcblas

##########################################################
## QWT - use local copy till upstream catches up
# http://qwt.sourceforge.net/index.html
##########################################################

# include path.
QWT_INCLUDEPATH = $$QTI_ROOT/3rdparty/qwt/src
# link locally against a copy in 3rdparty/
QWT_LIBS = $$QTI_ROOT/3rdparty/qwt/lib/libqwt.a

##########################################################
## QwtPlot3D - use local copy till upstream catches up
# http://qwtplot3d.sourceforge.net/
##########################################################

# include path.
QWT3D_INCLUDEPATH = $$QTI_ROOT/3rdparty/qwtplot3d/include
# link locally against a copy in 3rdparty/
win32:QWT3D_LIBS = $$QTI_ROOT/3rdparty/qwtplot3d/lib/qwtplot3d.dll
unix:QWT3D_LIBS = $$QTI_ROOT/3rdparty/qwtplot3d/lib/libqwtplot3d.a

##########################################################
## libpng - optional. you don't have to set these variables
##########################################################

# include path. leave it blank to use SYS_INCLUDE
# LIBPNG_INCLUDEPATH = $$QTI_ROOT/3rdparty/libpng/
# link statically against a copy in 3rdparty/
# LIBPNG_LIBS = $$QTI_ROOT/3rdparty/libpng/libpng.a
# or dynamically against a system-wide installation
LIBPNG_LIBS = -lpng

##########################################################
## QTeXEngine - optional. you don't have to set these variables
# http://soft.proindependent.com/qtexengine/
##########################################################

# include path.
TEX_ENGINE_INCLUDEPATH = $$QTI_ROOT/3rdparty/QTeXEngine/src
# link locally against a copy in 3rdparty/
TEX_ENGINE_LIBS = $$QTI_ROOT/3rdparty/QTeXEngine/libQTeXEngine.a

##########################################################
## ALGLIB (2.6) - optional. you don't have to set these variables
# http://www.alglib.net/
##########################################################

# include path.
ALGLIB_INCLUDEPATH = $$QTI_ROOT/3rdparty/alglib/src
# link locally against a copy in 3rdparty/
ALGLIB_LIBS = $$QTI_ROOT/3rdparty/alglib/out/libalglib.a

##########################################################
## TAMUANOVA - optional. you don't have to set these variables
# http://www.stat.tamu.edu/~aredd/tamuanova/
##########################################################

# include path.
TAMUANOVA_INCLUDEPATH = $$QTI_ROOT/3rdparty/tamu_anova/
# link locally against a copy in 3rdparty/
TAMUANOVA_LIBS = $$QTI_ROOT/3rdparty/tamu_anova/libtamuanova.a

##########################################################
## python - only used if python is needed
##########################################################

# the python interpreter to use
# (unix only, windows will use what ever is configured to execute .py files!)
PYTHON = python

##########################################################
## Qt tools - allows to use specific versions
##########################################################

LUPDATE = lupdate
LRELEASE = lrelease

############################################################
##  Target specific configuration: configure Qtiplot itself
############################################################

contains( TARGET, qtiplot ) {
  # building without muParser doesn't work yet
  SCRIPTING_LANGS += muParser
  SCRIPTING_LANGS += Python

  # a console displaying output of scripts; particularly useful on Windows
  # where running QtiPlot from a terminal is inconvenient
  DEFINES         += SCRIPTING_CONSOLE

  #DEFINES         += QTIPLOT_DEMO

  # Uncomment the following line if you want to perform a custom installation using the *.path variables defined in ./qtiplot.pro.
  #CONFIG          += CustomInstall

  # Uncomment the following line if you want to build QtiPlot as a browser plugin (not working on Internet Explorer).
  #CONFIG          += BrowserPlugin
  
  CONFIG          += release
  #CONFIG          += debug
  
  # Uncomment the following line if you want to link statically against Qt.
  #CONFIG           += StaticBuild
  #win32: CONFIG   += console
}

Non abbiamo ancora finito, dobbiamo fare un'ultima cosa. Modifichiamo il file qtiplot.pro che si trova nella cartella principale del codice sorgente. Questo contiene il nome di quali cartelle contengono del codice che dovrà essere compilato. Togliamo dall'elenco fitPlugins e manual (eventualmente potranno essere compilati successivamente), quindi il file apparirà più o meno così:

TEMPLATE = subdirs

SUBDIRS = 3rdparty/qwt \
        3rdparty/qwtplot3d \
        qtiplot

A questo punto dovremmo essere in grado, finalmente di compilare QtiPlot. Come spiegato nel file README.html i comandi da dare sono

qmake
make

make -j 4

Se la compilazione va a buon fine (come al solito possiamo controllarlo con echo $?) possiamo direttamente avviare QtiPlot, per vedere se funziona, inserendo il percorso relativo dell'eseguibile appena generato:

qtiplot/qtiplot

Infine si può, se lo si desidera, installare il programma con

sudo make install

oppure utilizzando checkinstall:

sudo checkinstall

che crea un semplice pacchetto .deb (il risultato, però, non è "professionale").

Emacs: aprire il file manager nella cartelle del buffer corrente

2011-02-19T16:26:00.003+01:00

In Emacs è presente una modalità chiamata Dired che funge da file manager. Tuttavia in qualche caso si potrebbe voler aprire il file manager dell'ambiente desktop in uso (o comunque un file manager esterno) direttamente nella cartella in cui si trova il file attualmente modificato (o meglio, il buffer corrispondente). Per fare ciò si può aggiungere il seguente codice all'interno del proprio file di inizializzazione (a meno che questa funzione non sia già presente in Emacs e io non sia in grado di trovarla):

(defun open-buffer-path ()
  "Run Nautilus on the directory of the current buffer."
  (interactive)
  (shell-command (concat "nautilus " default-directory)))

Questo codice definisce la funzione open-buffer-path che aprirà il file manager Nautilus (il predefinito di GNOME) nella cartella predefinita (che normalmente corrisponde alla cartella in cui si trova il file in uso, oppure alla propria home se il buffer aperto non corrisponde a un file). Se si vuole usare un file manager diverso basta sostituire il comando che compare come argomento di concat (e magari anche il Nautilus che compare nel rigo di descrizione della funzione).

Se lo si desidera si può associare una combinazione di tasti a questa funzione aggiungendo al proprio file di inizializzazione:

(global-set-key (kbd "<M-f3>") 'open-buffer-path)

Con questo codice verrà associata la combinazione M-f3 alla funzione open-buffer-path, se si vuole usare una combinazione diversa basta sostituire l'occorrenza di M-f3 nel codice precedente.

Questo post prende spunto da http://zhangda.wordpress.com/2010/02/03/open-the-path-of-the-current-buffer-within-emacs/ in cui è definita una funzione per aprire il file manager Explorer in Windows. A questo proposito trovate un codice alternativo qui: http://www.factsandpeople.com/facts-mainmenu-5/2-editor-emacs/80-switching-between-windows-explorer-and-emacs.

info: Impossibile trovare il nodo «Top». [Risolto]

2011-01-15T14:45:00.010+01:00

Non so bene per quale motivo (ma ho l'impressione che sia colpa di un aggiornamento di Ubuntu) non sono più in grado di usare info. Come spiegai in uno dei primi post di questo blog, per consultare da terminale i manuali (se presenti) dei comandi si può usare man:

man nomecomando

In aggiunta a man, molti programmi (soprattutto del progetto GNU) forniscono una guida (spesso più completa del manuale consultabile con man) che può essere letta con info:

info nomecomando

In questi giorni, dando il comando (per esempio)

info coreutils

(per leggere la guida delle principale utilità di sistema, chiamate appunto coreutils) ricevo dal terminale questa risposta:

info: Impossibile trovare il nodo «Top».

Il messaggio in lingua inglese è il seguente:

info: Cannot find node `Top'.

Il problema è che per qualche motivo si è corrotto il file /usr/share/info/dir che contiene (o, nel mio caso, dovrebbe contenere) l'elenco dei manuali che possono essere consultati con info. Il mio file /usr/share/info/dir conteneva solo questo:

Questo è il file .../info/dir, che contiene il
nodo più in alto della gerarchia di Info, chiamata (dir)Top.
La prima volta che invochi il programma Info esso parte da questo nodo.
^_
File: dir, Node: Top\tQuesto è il nodo più alto dell'albero INFO

Questo (il nodo principale) fornisce un menù che contiene le voci principali.
Digitando "q" esce, digitando "?" si produce un elenco di tutti i comandi Info,
"d" ritorna alla presente schermata, "h" fornisce informazioni ai nuovi utenti,
"mEmacs<return>" visualizza il manuale di Emacs, ecc.
All'interno di Emacs, puoi cliccare con il pulsante sinistro del mouse su una voce di menù
o su un riferimento incrociato per selezionarlo.

* Menu:

Come vedete, manca l'elenco dei manuali disponibili, che invece dovrebbe essere presente dopo la riga * Menu:.

Per risolvere il problema si può cancellare il file incriminato e rigenerarlo con il comando da terminale install-info (in Debian, Ubuntu e derivate bisogna richiamare il comando con ginstall-info). install-info accetta come primo argomento il file (in genere questi file hanno estensione .info e potrebbero essere compressi con gzip) che contiene il manuale che si vuole aggiungere all'elenco (questi file in genere si trovano nella cartella /usr/share/info/ e sue sottocartelle), come secondo argomento il file di elenco (cioè /usr/share/info/dir). Queste due operazioni possono essere automatizzate con i due seguenti comandi (richiedono i diritti di amministratore perché si modificherà un file di sistema):

sudo mv /usr/share/info/dir ~/dir
for file in /usr/share/info/*.{gz,info} /usr/share/info/*/*.{gz,info}; do sudo install-info "$file" /usr/share/info/dir; done

Se usate sistemi, come Debian o Ubuntu, che richiedono ginstall-info al posto di install-info, il secondo dei comandi precedenti va cambiato in

for file in /usr/share/info/*.{gz,info} /usr/share/info/*/*.{gz,info}; do sudo ginstall-info "$file" /usr/share/info/dir ; done

Breve spiegazione dei comandi consigliati: il primo comando (mv) serve per spostare il file nella propria home, conservando una copia di sicurezza (anche se il file è corrotto non fa male creare una copia, dopo aver risolto il problema la copia può essere tranquillamente cancellata); il secondo esegue un ciclo for su tutti i file con estensioni .gz o .info presenti nella cartella /usr/share/info sue sottocartelle. Se in questo modo non dovessero essere inclusi alcuni file di manuali, potete farlo manualmente tramite install-info (o ginstall-info) con la sintassi esposta precedentemente.

Aggiornamento importante: dopo il commento di Zio LoneWolf (che ringrazio) mi sono accorto che la questione era più complicata di quanto mi sembrasse inizialmente. Per risolvere il problema non è affatto sufficiente usare i comandi presentati in precedenza perché pare che sia presente un bug nella traduzione italiana di Texinfo. Si può aggirare (e questa volta per davvero) il problema impostando nella shell la lingua inglese e poi utilizzando nuovamente i comandi precedenti:

LANG=en_US.UTF-8
for file in /usr/share/info/*.{gz,info} /usr/share/info/*/*.{gz,info}; do sudo install-info "$file" /usr/share/info/dir; done

oppure

LANG=en_US.UTF-8
for file in /usr/share/info/*.{gz,info} /usr/share/info/*/*.{gz,info}; do sudo ginstall-info "$file" /usr/share/info/dir; done

L'aggiornamento del file /usr/share/info/dir può anche essere fatto con il comando update-info-dir (dato come al solito con privilegi di amministratore). Si può fare in modo che questo script utilizzi sempre la lingua inglese senza doverla impostare manualmente ogni volta. Aprite con il vostro editor di testo preferito (e con i diritti di amministratore) lo script /usr/sbin/update-info-dir. Per esempio con gedit si userà:

gksudo gedit /usr/sbin/update-info-dir

A questo punto inserite la stringa

unset LANG # https://bugs.launchpad.net/ubuntu/+source/texinfo/+bug/707931

(nel commento c'è un riferimento alla segnalazione del bug su Launchpad) per esempio dopo il rigo

unset LANGUAGE

Dopo di ciò sarà possibile aggiornare il file /usr/share/info/dir semplicemente con il comando

sudo update-info-dir

Altro aggiornamento: Giovanni segnala nei commenti che ha realizzato uno script per risolvere automaticamente il problema. Trovate lo script e le istruzioni per l'uso sul sito sito: http://www.ubaweb.it/miniguide/info_non_va.php.

Confrontare le differenze fra due documenti PDF (2)

2010-11-05T20:49:00.010+01:00

Qualche giorno fa ho illustrato un semplice script bash che permette di eseguire un confronto elementare fra due documenti PDF per cercarne le differenze. Tuttavia, come ho spiegato, questo script ha numerosi difetti perché cerca essenzialmente differenze nel testo dei due documenti (se è in grado di estrarre correttamente il testo da essi). Esiste però un programma a interfaccia grafica che permette di eseguire un confronto più efficace: DiffPDF. Questo pacchetto è fornito dalle principali distribuzioni GNU/Linux; in Debian, Ubuntu & Co. bisogna installare il pacchetto diffpdf con il Gestore pacchetti Synaptic oppure da terminale con il solito comando:

sudo apt-get install diffpdf

Per le altre distribuzioni fare riferimento al proprio gestore pacchetti.

Il programma può essere avviato dal lanciatore (in Ubuntu: Applicazioni → Accessori → DiffPDF) oppure da terminale con il comando

diffpdf

È possibile passare come argomenti i percorsi dei documenti che si vogliono confrontare:

diffpdf /percorso/del/file1.pdf /percorso/del/file2.pdf

Normalmente DiffPDF mette a confronto i testi dei documenti, ma, come potete vedere dallo screenshot seguente, è possibile anche effettuare un confronto visuale fra due documenti, per poter cercare differenze fra le immagini. Per fare ciò bisogna selezionare Appearance nel menu a tendina Comparison Mode in alto a destra e rieseguire il confronto con il pulsante Compare situato più in basso, sempre sul pannello di destra. Questa modalità potrebbe fornire dei falsi positivi (come succede nell'immagine proposta) perché non viene più confrontato solo del testo, ma comunque i risultati sono in genere molto buoni.

Anche qui propongo uno Script per Nautilus che permette di avviare DiffPDF con pochi clic selezionando i file che si desidera confrontare:

#!/bin/bash

titolo="Confronta PDF"

function controlla() {
    estensione=$(echo "$1" | cut -d. --complement -f1)
    case $estensione in
        [pP][dD][fF])
            ;;
        *)
            zenity --error --title="$titolo" --text="Devi selezionare due file con estensione \".pdf\"."
            exit 1
    esac
}

if [ $# -ne 2 ]; then
    zenity --error --title="$titolo" --text="Devi selezionare due file PDF alla volta."
    exit 1
fi
pdf1="$1"
pdf2="$2"
controlla "$pdf1" && controlla "$pdf2"
if [ $? -eq 0 ]; then
    diffpdf "$pdf1" "$pdf2"
else # non dovrebbe arrivare mai qui, metto per sicurezza
    zenity --error  --title="$titolo" --text="Si è verificato un errore."
    exit 1
fi
exit 0

Per utilizzare questo script aprite un file vuoto con un editor di testo, copiate lo script nell'editor e salvatelo nella cartella ~/.gnome2/nautilus-scripts (ricordo che la tilde ~ è un'abbreviazione della cartella home dell'utente corrente) chiamandolo, per esempio, "Confronta PDF". Rendete eseguibile lo script e così potrete selezionare due file PDF da confrontare che si trovano nella stessa cartella e, facendo clic con il tasto destro, scegliete Script → Confronta PDF (o il nome che avete dato allo script).

Confrontare le differenze fra due documenti PDF

2010-10-26T16:38:00.008+02:00

Nota: qui suggerisco il programma a interfaccia grafica DiffPDF che permette di effettuare un confronto più efficace fra due documenti PDF.

Un semplice metodo per confrontare due documenti in formato PDF è sfruttare l'accoppiata pdftotext (per convertire i PDF in testo puro) + diff (per controllare le differenze). Mi ero stancato di eseguire tutti i soliti comandi allora ho scritto questo script fresco fresco:

#!/bin/bash

function converti() {
    txt=$(eval "expr \$"$1" ")
    pdf=$(eval "expr \$"$2" ")
    scelta=""
    while [ -f "$txt" ]; do
        read -p "Il file $txt esiste già, sovrascriverlo? [s/n]: " scelta
        case "$scelta" in
            s|S|y|Y)
                break 2
                ;;
            n|N)
                read -p "Specifica un file di output differente: " txt
                ;;
        esac
    done
    if ! pdftotext "$pdf" "$txt"; then
        exit 1
    fi
    eval "$1=$txt"
}

if [ $# -ne 2 ]; then
    echo "Uso: $0 PDF1 PDF2"
    exit 1
fi
pdf1=$1
pdf2=$2
txt1=$(dirname "$pdf1")/$(basename "$pdf1" .pdf).txt
txt2=$(dirname "$pdf1")/$(basename "$pdf2" .pdf).txt
converti txt1 pdf1 && converti txt2 pdf2
if [ $? -eq 0 ]; then
    diff -u "$txt1" "$txt2" | less
fi
rm -f "$txt1" "$txt2"
exit 0

Per utilizzarlo basta copiare lo script in un file con un editor di testo a piacere, salvare il file chiamandolo, per esempio, pdf-diff, renderlo eseguibile e posizionarlo nella cartella ~/bin (ricordo che la tilde ~ è un'abbreviazione della cartella home dell'utente corrente), creandola se eventualmente non esiste. Date nel terminale il comando

. ~/.profile

(per i curiosi serve a caricare il file ~/.profile che aggiunge la cartella $HOME/bin alla variabile d'ambiente $PATH), dopo di ciò dovrebbe essere sufficiente dare nel terminale il comando

pdf-diff /percorso/del/primo/file /percorso/del/secondo/file

(o il nome che avete dato allo script).

Non sarà perfetto, ha tutti i limiti che si riscontrano nel passaggio da un PDF a un file di testo puro (per esempio se cambia un'immagine non se ne accorge e la buona riuscita del confronto dipende da quanto bene pdftotext riesce a leggere i documenti) ma è abbastanza veloce e ho trovato questo sistema spesso molto utile.

Ho scritto anche il corrispondente script Nautilus (utilizza zenity):

#!/bin/bash

titolo="Confronto PDF"

function converti() {
    txt=$(eval "expr \$"$1" ")
    pdf=$(eval "expr \$"$2" ")
    while [ -f "$txt" ]; do
        if ! zenity --question --title="$titolo" --text="Il file $txt esiste già, sovrascriverlo?"; then
            txt=$(zenity --entry  --title="$titolo" --text="Specifica un file di output differente: ")
        else
            break 2
        fi
    done
    pdftotext "$pdf" "$txt"
    case $? in
        0)
            ;;
        1)
            zenity --error  --title="$titolo" --text="Si è verificato un errore nell'apertura di $pdf."
            exit 1
            ;;
        2)
            zenity --error  --title="$titolo" --text="Si è verificato un errore nell'apertura di $txt."
            exit 1
            ;;
        3)
            zenity --error  --title="$titolo" --text="Si è verificato un errore collegato ai permessi di $pdf."
            exit 1
            ;;
        *)
            zenity --error  --title="$titolo" --text="Si è verificato un errore!"
            exit 1
    esac
    eval "$1=$txt"
}

if [ $# -ne 2 ]; then
    zenity --error --title="$titolo" --text="Devi selezionare due file alla volta"
    exit 1
fi
pdf1=$1
pdf2=$2
txt1=$(dirname "$pdf1")/$(basename "$pdf1" .pdf).txt
txt2=$(dirname "$pdf1")/$(basename "$pdf2" .pdf).txt
converti txt1 pdf1 && converti txt2 pdf2
if [ $? -eq 0 ]; then
    diff -u "$txt1" "$txt2" | zenity --text-info  --title="$titolo" --filename=/dev/stdin
    rm -f "$txt1" "$txt2"
else # non dovrebbe arrivare mai qui, metto per sicurezza
    zenity --error  --title="$titolo" --text="Si è verificato un errore!"
    exit 1
fi
exit 0

Per utilizzare questo secondo script aprite un file vuoto con un editor di testo, copiate lo script nell'editor e salvatelo nella cartella ~/.gnome2/nautilus-scripts chiamandolo, per esempio, "Confronta PDF". Rendete quindi eseguibile lo script. Così potrete selezionare due file PDF da confrontare e, facendo clic con il tasto destro, scegliete Script → Confronta PDF (o il nome che avete dato allo script).

Dal punto di vista tecnico, gli script presentano un aspetto un po' particolare: la funzione converti (che serve per convertire il pdf in testo ed eseguire i controlli del caso) presenta una sorta di passaggio di variabile per riferimento e non per valore. Il "trucco" sta nel passare alla funzione non il valore della variabile ma il suo nome (chi ha familiarità con altri linguaggi di programmazione potrebbe trovare ciò naturale). I dettagli possono essere visti qui: http://www.pluto.it/files/ildp/guide/abs/functions.html#DEREFERENCECL.

Importare in Gmail la posta inviata di un altro account

2010-10-23T17:28:00.005+02:00

Questa volta parlerò di un problema non legato al sistema operativo GNU/Linux, però è un problema che mi ha tenuto impegnato per un po' e voglio spiegare il barbatrucco con cui l'ho risolto: importare in Gmail la posta inviata di un altro account.

In Gmail è possibile importare le email ricevute da un qualsiasi altro account di posta elettronico nel proprio account su Gmail. Se si vuole è possibile anche continuare a scaricare automaticamente la posta da altri account (al massimo 5) con la funzione chiamata Mail Fetcher. Purtroppo né l'importazione manuale della posta né Mail Fetcher importano anche le email inviate dagli altri account, come spiegato nella sezione di Risoluzione dei problemi della guida. È vero che non è possibile farlo automaticamente, ma con qualche giro sono riuscito nel mio intento. Per fare ciò ho dovuto dare un'occhiata all'organizzazione della posta su Gmail. Il barbatrucco funziona pienamente se l'account da cui si vogliono importare le email verrà aggiunto ai mittenti personalizzati.

Le mail (che normalmente sono raccolte per conversazioni, se non vi piace questa visualizzazione potete disattivarla da Impostazioni e nella scheda Generali selezionate Visualizzazione per conversazione disattivata) non sono suddivise in cartelle ma hanno delle "etichette" che vengono loro attribuite. L'uso è praticamente lo stesso, la differenza è che a una mail possono essere attribuite più etichette, è come se si trovasse in più cartelle contemporaneamente. Tutte le mail si trovano nello spazio chiamato Tutti i messaggi (il collegamento sta nella barra sulla sinistra, se non la vede premete Altre), non vengono però visualizzate le email eliminate (le quali hanno l'etichetta Cestino) e quelle segnate come spam (che hanno l'etichetta Spam). (quasi) Tutti i "gruppi" che vediamo sulla sinistra non fanno altro che raccogliere le email secondo le etichette che le sono state attribuite. Così, le email posizionate in Posta in arrivo sono semplicemente delle mail che hanno l'etichetta Posta in arrivo (per quanto possa sembrare strano, una email inviata può trovarsi in Posta in arrivo: basta che abbia la corrispondente etichetta), le eventuali email presenti in Personale, Lavoro, ecc. hanno le rispettive etichette e, come detto, una mail può anche avere più etichette contemporaneamente (e quindi comparirà in tutti i rispettivi "gruppi"). Invece le mail presenti in Posta inviata hanno come caratteristica di avere come mittente l'account in uso o uno dei mittenti personalizzati.

Vi starete chiedendo: cosa c'entra tutto questo discorso con l'importazione delle email inviate? Calma, arriviamo subito alla soluzione del problema facendo un breve riepilogo di quello che abbiamo appreso. Sappiamo che Gmail può importare dagli altri account la posta arrivata, ma non quella inviata, allora potremmo pensare di spostare nel precedente account le email inviate nella cartella di Posta in arrivo (in genere questa è una operazione possibile, naturalmente non posso spiegare i dettagli perché variano da provider a provider), ma questa operazione crea l'inconveniente che importando la posta nell'account Gmail le email inviate avranno l'etichetta Posta in arrivo e quindi si troveranno in quel gruppo (a meno che nella fase di importazione non si sia selezionata l'opzione Archivia messaggi in arrivo (Ignora Posta in arrivo)). Sappiamo però anche che per togliere una mail dalla Posta in arrivo basta rimuovere la corrispondente etichetta, niente di più semplice! Ho già specificato che il barbatrucco funziona se l'indirizzo da cui stiamo importando la posta è uno dei mittenti personalizzati, quindi le email si troveranno già automaticamente in Posta inviata, altrimenti non compariranno in questa "cartella" ma solo in Tutti i messaggi (e se questa eventualità non è un problema allora non diventa neanche necessario che l'account da cui si importa sia fra i mittenti personalizzati).

Per non dover rimuovere manualmente le etichette a ciascun messaggio inviato consiglio di suddividere l'operazione di importazione in due punti:
1) importare normalmente nell'account Gmail tutta la posta arrivata al precedente account;
2) dopo aver concluso questa operazione, spostare (nel vecchio account) le email inviate nella cartella ed eseguire nuovamente lo scaricamento in Gmail (tranquilli, le email già importate non saranno scaricate nuovamente) selezionando l'opzione Archivia messaggi in arrivo (Ignora Posta in arrivo). In questo modo, come spiegato già abbastanza bene dal nome dell'opzione, le nuove email che saranno scaricate (nella speranza che ci siano solo le email inviate e non compaia qualche nuova mail :-D ) verranno archiviate, cioè non sarà aggiunta l'etichetta Posta in arrivo.

Nel vecchio account da cui avete importato le email potete ora fare quello che vi pare: riportare le email inviate nella cartella di posta inviata, cancellarle, ecc. Ovviamente è possibile selezionare l'opzione Archivia messaggi in arrivo (Ignora Posta in arrivo) già nell'importazione di tutte le mail ricevute, in questo caso non si rende neanche necessaria una doppia importazione, si possono importare tutte insieme email ricevute e inviate (naturalmente dopo aver spostato queste ultime nella cartella di posta ricevuta). Se si utilizza Mail Fetcher, dopo aver effettuato l'importazione dei messaggi inviati potreste voler togliere l'opzione Archivia messaggi in arrivo: ricordatevi di farlo, altrimenti le nuove mail ricevute sul vecchio account non passeranno da Posta in arrivo!

Questo è il barbatrucco che ho escogitato io, non escludo che esista qualche metodo più semplice, in questo caso sarei felice di conoscerlo! :-)

Opzioni utili per comporre documenti LaTeX in GNU Emacs + AUCTeX

2010-10-22T23:54:00.002+02:00

GNU Emacs, come ho già avuto modo di dire, è un potente editor di testo che permette di fare di tutto e di più. Esistono numerose funzioni che permettono di facilitare la scrittura di codici in numerosi linguaggi di programmazioni, compreso, ovviamente LaTeX (anche se in questo caso il nome "linguaggio di programmazione" non è del tutto adeguato). Uno dei tanti motivi per cui Emacs è molto apprezzato è la sua possibilità di personalizzazione ed espansione: esistono centinaia di estensioni che aumentano notevolmente le potenzialità di questo editor di testo oltre le funzioni fornite nativamente. Esiste (ovviamente) una estensione anche per LaTeX: AUCTeX (ma è utile anche per ConTeXt, docTeX, Texinfo e TeX puro: molte delle impostazioni che vedremo varranno per tutti questi linguaggi, anche se mi riferirò generalmente solo a LaTeX).

Non è mia intenzione spiegare qui come si installa Emacs né tanto meno AUCTeX (anche perché questi pacchetti sono forniti dalla maggior parte delle distribuzioni GNU/Linux, l'installazione è quindi molto semplice se si conosce il funzionamento del proprio gestore pacchetti), ma piuttosto illustrare quali sono le opzioni di AUCTeX (e qualcuna propria di Emacs) che ho trovato personalmente utili. Darò per scontato che si abbia un minimo di familiarità con Emacs, con la notazione delle scorciatoie e dei comandi e anche con AUCTeX (qualche volta però ricorderò come eseguire alcune operazioni). Prima di iniziare ricordo che si può consultare il manuale (in inglese) di AUCTeX all'indirizzo http://www.gnu.org/software/auctex/manual/auctex.html oppure direttamente dentro Emacs con C-h i d m AUCTeX RET. Per la modifica di buona parte delle opzioni seguenti AUCTeX dovrà essere già caricato. Non sono un grande esperto di Emacs, potrei dire a volte delle sciocchezze, spero che mi perdoniate e sono graditi consigli (a ogni modo vi posso assicurare che seguendo questa guida non vi scoppierà il pc :-D).

In AUCTeX è possibile eseguire varie operazioni come compilazione, esecuzione di bibtex, esecuzione di makeindex, cancellazione dei file temporanei, ecc... usando C-c C-c (seguito dal comando che si desidera usare). La cancellazione dei file temporanei viene eseguita usando l'elenco delle estensioni dei file salvato nella variabile LaTeX-clean-intermediate-suffixes. Per modificare questa variabile (come tutte le variabili di Emacs, naturalmente sostituendo il nome dove opportuno) si può usare il comando (ricordo che i comandi possono essere inseriti con M-x, dove M è il cosiddetto tasto Meta e può essere ottenuto con l'ALT, oppure, se non è presente tale tasto, con ESC (rilasciare ESC dopo averlo premuto)):

customize-variable RET LaTeX-clean-intermediate-suffixes RET

Per aggiungere nuove estensioni selezionare INS e inserire di fianco a Regexp: l'espressione regolare (per maggiori informazioni sulle espressioni regolari in Emacs si può consultare il manuale di Elisp in Emacs oppure vedere qui) corrispondente all'estensione che si vuole aggiungere. Per esempio io ho aggiunto le estensioni .tex~ (i file di backup creati da Emacs) e .run.xml (file usati per creare la bibliografia con il pacchetto biblatex) con le seguenti espressioni regolari:

\.tex~
\.run\.xml

Per rendere definitiva la modifica selezionare Save for future sessions (bisognerà fare lo stesso ogni volta che si usa customize-variable).

Emacs si preoccupa anche di indentare correttamente il codice, compresi i vari ambienti. Si può in particolare impostare l'editor in modo che quando viene premuto il tasto di Invio (o, nella notazione di Emacs, RET) il cursore si porti, nel rigo successivo, nella giusta posizione richiesta da una corretta indentazione. Per fare ciò bisogna modificare la variabile TeX-newline-function con il comando:

customize-variable RET TeX-newline-function RET

Selezionare Value Menu e scegliere newline-and-indent. È possibile anche modificare il comportamento di Emacs nell'indentazione all'interno di determinati ambienti modificando la variabile LaTeX-indent-environment-list, sempre con il comando:

customize-variable RET LaTeX-indent-environment-list RET

Io, per esempio, ho aggiunto l'ambiente lstlisting per fare in modo che Emacs non aggiungesse automaticamente il rientro per il testo inserito in questo ambiente. Per fare ciò ho selezionato INS, scritto lstlisting di fianco a Environment: e dopo aver messo la spunta a Function: ho scritto nel relativo spazio current-indentation (proprio come risulta di default per l'ambiente verbatim).

Emacs permette anche l'evidenziazione della sintassi di LaTeX, ma in alcuni (rari) casi può andare in difficoltà. Per esempio ho avuto problemi con il già citato ambiente lstlisting in quanto AUCTeX 11.86 non conosce bene il suo funzionamento (per esempio l'inserimento del simbolo del dollaro $ rovina tutta l'evidenziazione del documento). Per fortuna è possibile spiegargli che lo deve trattare allo stesso modo dell'ambiente verbatim (in pratica tutto ciò che si trova all'interno di questo ambiente non viene interpretato da Emacs per quanto riguarda l'evidenziazione della sintassi) modificando la variabile LaTeX-verbatim-environments:

customize-variable RET LaTeX-verbatim-environments RET

aggiungete lstlisting (penso che ormai avrete capito come funziona questo tipo di interfaccia di modifica delle variabili) e il gioco è fatto.

In maniera predefinita Emacs compila i documenti in formato DVI. Se invece si vuole impostare in maniera predefinita il formato PDF bisogna modificare il valore della variabile TeX-PDF-mode:

customize-variable RET TeX-PDF-mode RET

Selezionare Toggle fino ad arrivare a on (non-nil).

Se si è installata una distribuzione di LaTeX in un percorso non riconosciuto immediatamente da Emacs e AUCTeX bisognerà modificare alcune variabili. Per esempio, io ho installato TeX Live 2010 seguendo questa guida di Enrico Gregorio e tutti i file di LaTeX si trovano in sottocartelle di /usr/local/texlive/2010/ (in cui Emacs e AUCTeX normalmente non cercano). Fra le variabili che potrebbero dover essere cambiate ci sono TeX-macro-global (contiene, ricorsivamente, le cartelle in cui AUCTeX cercherà i file di stile) e exec-path (contiene i percorsi in cui Emacs cerca i programmi da eseguire). La modifica di queste variabili è simile a quanto visto finora. Per la prima variabile ho aggiunto il percorso /usr/local/texlive/2010/texmf-dist/tex/, mentre per exec-path ho aggiunto /usr/local/texlive/2010/bin/i386-linux/ (su architetture diverse dal 32 bit questo percorso sarà sicuramente diverso. Controllate per bene la posizione in cui avete installato la distribuzione).

Per modificare il programma con cui viene aperto il documento di output (sia esso in formato DVI, PDF, HTML, ecc) tramite C-c C-c View RET bisogna modificare la variabile TeX-view-program-selection. Come al solito per personalizzare la variabile si può usare

customize-variable RET TeX-view-program-selection RET

Le impostazioni viste finora vengono salvate automaticamente da Emacs nel file di inizializzazione ~/.emacs (ricordo che la tilde ~ è un'abbreviazione del percorso della propria cartella home, mentre i file che hanno il nome che inizia con un punto sono nascosti). Tutte queste impostazioni possono essere anche memorizzate modificando manualmente il file .emacs (per poter fare ciò autonomamente bisogna però conoscere il linguaggio Emacs Lisp). Vediamo ora qualche altra utile opzione che imposteremo modificando direttamente il file .emacs (queste comunque possono sempre essere impostate anche utilizzando l'interfaccia di customize-variable).

Il manuale di AUCTeX suggerisce di aggiungere a .emacs le seguenti linee:

(setq TeX-auto-save t)
(setq TeX-parse-self t)

in modo che ottenere supporto per i pacchetti LaTeX che vengono usati nei propri documenti (l'opzione TeX-parse-self fa effettuare a Emacs il parsing del documento e le informazioni verranno raccolte in una sottocartella della directory del documento modificato chiamata auto/. Se non si desidera affollamento nelle proprie cartelle si potrebbe non voler attivare queste due opzioni).

Se si usa frequentemente suddividere i propri documenti LaTeX in più parti da includere nel file principale con i comandi \input o \include può essere utile aggiungere al file .emacs l'opzione

(setq-default TeX-master nil)

In questo modo, all'apertura dei documenti LaTeX Emacs chiederà qual è il file principale associato (su cui dovrà, per esempio, eseguire i comandi di compilazione).

Si può far in modo che all'apertura di un documento LaTeX Emacs esegua il controllo ortografico al volo aggiungendo a .emacs l'opzione

(add-hook 'TeX-mode-hook 'flyspell-mode)

Inoltre, se si usa spesso LaTeX per comporre documenti matematici potrebbe essere utile aggiungere l'opzione

(add-hook 'TeX-mode-hook 'LaTeX-math-mode)

che permette il rapido inserimento di numerosi simboli matematici (vedi manuale). Infine, per fare in modo che il cursore vada a capo dopo l'inserimento di un numero prefissato di caratteri per rigo (ovviamene Emacs è intelligente, non spezza una parola in due, va a capo in modo che il rigo risulti lungo al massimo il numero prefissato di caratteri) si può aggiungere l'opzione

(add-hook 'TeX-mode-hook 'turn-on-auto-fill)

Il numero di caratteri per rigo dopo il quale Emacs dovrà andare a capo è salvato nella variabile fill-column. Lascio per esercizio scoprire come si modifica tale variabile (ok, lascio un indizio: si può usare sempre il solito comando :-D).

Per effettuare un controllo della sintassi al volo si può inserire questo codice nel file di inizializzazione:

(require 'flymake)
(defun flymake-get-tex-args (file-name)
  (list "chktex" (list "-q" "-v0" file-name)))
(add-hook 'LaTeX-mode-hook 'flymake-mode)

I dettagli di questa istruzioni e sue alternative sono illustrati nel post Emacs: effettuare il controllo della sintassi di documenti LaTeX.

Ipe: An error occurred during the Pdflatex run. There was an error reading the Pdflatex output [Risolto]

2010-10-09T15:19:00.006+02:00

Se avete installato la distribuzione TeX Live 2010 e usate il programma di grafica Ipe per creare disegni, andando a compilare un'immagine potreste ricevere la seguente finestra di errore:

An error occurred during the Pdflatex run

There was an error reading the Pdflatex output

La soluzione a questo problema si trova(va) qui: http://http.typke.com/cgi-bin/bugzilla3/show_bug.cgi?id=350 e consiste nell'aggiungere al preambolo dell'immagine il comando \pdfobjcompresslevel0. Ricordo che il preambolo di un'immagine Ipe può essere modificato da Edit → Document properties (oppure con la scorciatoia da tastiera CTRL + Shift + P), scrivendo nel campo Latex preamble.

Git4LaTeX: una guida introduttiva a Git per progetti LaTeX

2010-10-09T14:39:00.006+02:00

Chi scrive documenti con LaTeX potrebbe a un certo punto avere il bisogno di controllare lo sviluppo dei vari documenti, in modo da controllare i cambiamenti effettuati tra un salvataggio e l'altro per poter, eventualmente, anche individuare quando sono stati introdotti degli errori e poter in pochi passi ripristinare una versione precedente. In vostro soccorso arriva allora Git, programma di controllo versione. L'uso tipico di Git è quello di tenere traccia dello sviluppo di un software, ma svolge ugualmente bene il suo lavoro con i documenti LaTeX.

Proprio per spiegare come utilizzare insieme Git e LaTeX, sul forum del Guit l'utente dianoia ha annunciato la realizzazione di una guida (con licenza CC-BY-NC-SA 2.5 Italy) sull'uso di Git per gestire lo sviluppo di un documento scritto in LaTeX. La guida non si prefigge grandi scopi, non diventerete degli esperti di Git leggendola, ma è sicuramente d'aiuto per riuscire a usare insieme questi due utili strumenti.

Trovate il codice sorgente della sua guida di dianoia su Gitorious all'indirizzo http://www.gitorious.org/git4latex e potete scaricare il documento PDF (che potrebbe risultare non aggiornato) all'indirizzo http://hotfile.com/dl/74484041/9c21bb8/git4latex.pdf.html. Se avete Git sul vostro sistema potete potete clonare il repository con il comando

git clone git://gitorious.org/git4latex/git4latex.git

Infine il codice sorgente può essere scaricato anche in un archivio compresso all'indirizzo http://www.gitorious.org/git4latex/git4latex/archive-tarball/master.

Visto che l'utente ha saggiamente pensato di utilizzare una licenza libera per questa utile guida ho realizzato un fork che potete trovare sempre su Gitorious all'indirizzo http://www.gitorious.org/~elrondgit/git4latex/elrondgits-git4latex/commits/elrond, il PDF (anche questo non sempre aggiornato) può essere scaricato all'indirizzo http://elubuntu.altervista.org/LaTeX/git4latex.pdf. Sempre se avete Git installato nel sistema potete clonare il repository con il comando

git clone git://gitorious.org/~elrondgit/git4latex/elrondgits-git4latex.git elrondgits-git4latex
cd elrondgits-git4latex # per entrare nella cartella
git checkout elrond # per aprire il branch

(gli ultimi due comandi, come spiegato nei commenti, servono per visualizzare il mio branch). Per finire anche questo lungo elenco di indirizzi segnalo che il mio branch può essere scaricato in un archivio compresso all'indirizzo http://www.gitorious.org/git4latex/elrondgits-git4latex/archive-tarball/elrond.

Qualsiasi critica (costruttiva), segnalazione di imprecisione o richiesta di chiarimento è ben gradita!

Happy TeXing :)

Compilare gnuplot 4.4 con il supporto per il terminale Lua/TikZ

2010-09-20T17:33:00.000+02:00

Da qualche tempo è uscita la versione 4.4 gnuplot. Gli utenti di Debian Sid/Squeeze possono installarla normalmente con il gestore pacchetti, gli utenti di Ubuntu Lucid Lynx possono scaricare i pacchetti deb dagli archivi di Debian: http://packages.debian.org/sid/gnuplot. Questa versione di gnuplot introduce inoltre il supporto nativo al terminale Lua/TikZ, utile per l'inserimento di grafici in documenti LaTeX (ricordo che comunque è presente anche il terminale epslatex per fare ciò). Il pacchetto presente in Debian Sid, però, al momento non supporta questo terminale quindi la compilazione del programma a partire dal sorgente è una delle strade possibili per poterlo utilizzare.

Ovviamente per compilare il programma la prima cosa da fare è procurarsi il codice sorgente. Questo può essere trovato qui. Come secondo passo bisogna installare le dipendenze per la compilazione. Un elenco delle librerie da installare può essere trovata qui (nelle altre distribuzioni i nomi potrebbero differire leggermente): http://packages.debian.org/source/sid/gnuplot. Nei sistemi che utilizzano APT (come Debian e Ubuntu) e in cui il sorgente di gnuplot è presente nei repository è possibile installare tutte queste dipendenze con il comando

sudo apt-get build-dep gnuplot

Per poter utilizzare il terminale Lua/TikZ è però necessario installare inoltre l'interprete Lua e le librerie necessarie per la compilazione. In Debian e Ubuntu è sufficiente installare il pacchetto liblua5.1-0-dev. Prima di continuare bisogna creare un link simbolico:

sudo ln -s /usr/lib/pkgconfig/lua5.1.pc /usr/lib/pkgconfig/lua.pc

Senza questa operazione non verrebbe individuata la presenza di Lua in fase di compilazione di gnuplot.

A questo punto bisogna scompattare l'archivio compresso appena scaricato e spostarsi con il terminale nella cartella in cui ora si trova il sorgente. Per compilare il programma, con il supporto al terminale Lua/TikZ bisogna dare i comandi

./configure --with-lua
make
sudo make install

Dopo l'esecuzione dello script configure controllate che lo script Lua sia presente fra quelli che verranno compilati. Al posto del comando sudo make install potete usare

sudo checkinstall

dopo aver installato il pacchetto checkinstall, che creerà un pacchetto deb per una più semplice rimozione e installazione del programma.

Creare un metapacchetto deb con equivs

2010-09-20T17:31:00.004+02:00

Seguite queste istruzioni a vostro rischio e pericolo, non assicuro che non possano creare qualche dipendenza rotta.

In APT (il sistema che gestisce i pacchetti di Debian, Ubuntu e compagnia) i metapacchetti (o dummy packages, pacchetti silenziosi) sono dei pacchetti che non forniscono un vero e proprio software ma che permettono di installare come dipendenze altri programmi. È, per esempio, un metapacchetto ubuntu-desktop: in sé non installa nessun programma, ma fa installare come dipendenze tutti i programmi presenti di default nella versione desktop di Ubuntu.

È possibile creare (in Debian e Ubuntu) dei metapacchetti con il programma equivs. Si installa normalmente da repository. Come al solito si può scegliere la via grafica installando con Synaptic il pacchetto equivs, oppure da terminale con il comando

sudo apt-get install equivs

equivs, che funziona da terminale, fornisce due comandi: equivs-control ed equivs-build. Il primo genera il file di configurazione del metapacchetto che si vorrà creare:

equivs-control nomepacchetto

creerà un file chiamato nomepacchetto (ovviamente sostituirete a nomepacchetto il nome del metapacchetto che vi interessa creare). Il file deve essere modificato con un qualsiasi editor di testo affinché contenga le impostazioni desiderate. Le opzioni che devono essere necessariamente presenti sono Package, Description e Depends. Ricordarsi di rimuovere il cancelletto (decommentare) davanti a tutte le opzioni modificate.

Con

equivs-build nomepacchetto

(nomepacchetto deve essere il nome del file creato con il comando precedente) si costruisce nella stesa cartella il pacchetto deb sulla base delle informazioni contenute nel file appena impostato che potrà essere installato facendoci doppio clic sopra oppure ancora da terminale con il comando

sudo dpkg -i nomepacchetto.deb

(il nome però non sarà semplicemente nomepacchetto.deb ma conterrà il numero della versione e l'architettura impostate, usate l'autocompletamento con il tasto TAB per sapere qual è il nome, oppure semplicemente controllatelo aprendo la cartella).

Un dei possibili usi dei metapacchetti è quello di poter installare con un solo doppio clic numerosi programmi (inserendoli come dipendenze del metapacchetto creato), oppure far credere al sistema APT che sia installato un determinato programma quando lo si è installato in maniera diversa (per esempio attraverso la compilazione del codice sorgente).

In questi giorni ho installato la distribuzione TeX Live 2010 dal sito e voglio che APT veda tutti i pacchetti relativi a TeX Live siano installati (perché la distribuzione è installata all'esterno del gestore pacchetti APT, ma lui non è a conoscenza di ciò ovviamente), in modo da poter installare altri programmi dipendenti da questi pacchetti. Per fare ciò ho creato il file texlive con il seguente contenuto:

Section: tex
Package: texlive-dummy
Version: 2011
Homepage: http://tug.org/texlive/
Standards-Version: 3.9.2
Provides: asymptote, asymptote-doc, biblatex, biblatex-dw, cm-super, context, dblatex, dvipdfmx, dvipng, feynmf, fragmaster, guile-1.8, jadetex, lacheck, latex2html, latex-beamer, latex-cjk-all, latexmk, latex-xcolor, lcdf-typetools, libsigsegv0, lilypond, lilypond-data, lilypond-doc, lmodern, luatex, passivetex, pgf, preview-latex-style, prosper, ps2eps, psutils, t1utils, tex4ht, tex4ht-common, tex-common, texlive, texlive-base, texlive-base-bin, texlive-base-bin-doc, texlive-bibtex-extra, texlive-binaries, texlive-common, texlive-doc-base, texlive-doc-bg, texlive-doc-cs+sk, texlive-doc-de, texlive-doc-en, texlive-doc-es, texlive-doc-fi, texlive-doc-fr, texlive-doc-it, texlive-doc-ja, texlive-doc-ko, texlive-doc-mn, texlive-doc-nl, texlive-doc-pl, texlive-doc-pt, texlive-doc-ru, texlive-doc-si, texlive-doc-th, texlive-doc-tr, texlive-doc-uk, texlive-doc-vi, texlive-doc-zh, texlive-extra-utils, texlive-fonts-extra, texlive-fonts-extra-doc, texlive-fonts-recommended, texlive-fonts-recommended-doc, texlive-font-utils, texlive-formats-extra, texlive-games, texlive-generic-extra, texlive-generic-recommended, texlive-humanities, texlive-humanities-doc, texlive-lang-african, texlive-lang-arabic, texlive-lang-armenian, texlive-lang-croatian, texlive-lang-cyrillic, texlive-lang-czechslovak, texlive-lang-danish, texlive-lang-dutch, texlive-lang-finnish, texlive-lang-french, texlive-lang-german, texlive-lang-greek, texlive-lang-hebrew, texlive-lang-hungarian, texlive-lang-indic, texlive-lang-italian, texlive-lang-latin, texlive-lang-latvian, texlive-lang-lithuanian, texlive-lang-mongolian, texlive-lang-norwegian, texlive-lang-other, texlive-lang-polish, texlive-lang-portuguese, texlive-lang-spanish, texlive-lang-swedish, texlive-lang-tibetan, texlive-lang-ukenglish, texlive-lang-vietnamese, texlive-latex3, texlive-latex-base, texlive-latex-base-doc, texlive-latex-extra, texlive-latex-extra-doc, texlive-latex-recommended, texlive-latex-recommended-doc, texlive-luatex, texlive-math-extra, texlive-metapost, texlive-metapost-doc, texlive-music, texlive-omega, texlive-pictures, texlive-pictures-doc, texlive-plain-extra, texlive-pstricks, texlive-pstricks-doc, texlive-publishers, texlive-publishers-doc, texlive-science, texlive-science-doc, texlive-xetex, tipa, xmltex
Architecture: all
Description: texlive dummy package

Quelli elencati in Provides sono i pacchetti della distribuzione TeX Live che ho trovato o che comunque avevo bisogno di far finta che fossero installati, ne esistono molti altri non presenti in questo elenco. Con il comando

equivs-build texlive

ho generato il pacchetto deb che ho potuto installare con un doppio clic.

Come suggerito nella documentazione (in particolare nel manuale di equivs-build), se riscontrate qualche caso in cui il sistema delle dipendenze dei pacchetti dovrebbe essere migliorato, non usate equivs ma piuttosto segnalate agli sviluppatori il problema.

Qui trovate altre informazioni sulla gestione dei metapacchetti: http://guide.debianizzati.org/index.php/Gestione_dei_metapacchetti.

Touchpad non funzionante in Ubuntu Lucid Lynx [Risolto]

2010-07-27T21:40:00.003+02:00

Nella versione 10.04 di Ubuntu (nome in codice Lucid Lynx, ma ho ricevuto segnalazioni di questo problema anche nelle versioni successive) può capitare che dopo l'avvio della sessione il mouse smetta di funzionare. Il problema è stato segnalato su Launchpad, intanto esistono un paio di risoluzioni.

La prima è un semplice workaround per aggirare momentaneamente il problema quando si presenta: entrare in una console con i tasti ALT + CTRL + F1 e poi, senza fare altro, tornare nella shell grafica con la combinazione ALT + CTRL + F7.

Un'altra soluzione che dovrebbe invece essere definitiva (ma che personalmente non ho testato, però più di qualcuno conferma essere funzionante) è dare questo comando nel terminale:

gconftool --type bool --set /desktop/gnome/peripherals/touchpad/touchpad_enabled true

Ho trovato questa seconda soluzione qui: https://bugs.edge.launchpad.net/ubuntu/+source/xserver-xorg-input-synaptics/+bug/549727/comments/103

Come si installa un .tar.gz?

2010-07-18T11:01:00.005+02:00

Una domanda abbastanza frequente sul forum della comunità italiana di Ubuntu è su come installare un .tar.gz (o anche un .tar.bz2 e compagnia bella). La risposta è semplice:

la domanda non ha senso.

Un .tar.gz (o un .tar.bz2) è un insieme di file archiviati con tar e compresso con gzip (o bzip2 nel caso dei .tar.bz, negli altri formati cambierà il tipo di compressione), ma dentro può esserci qualsiasi cosa (binari precompilati, sorgenti da compilare a mano, programma in python che non va compilato, temi per il desktop, chi più ne ha più ne metta) ed è per questo motivo che non ha senso chiedere come si installi. In generale non si può dire niente su cosa si debba fare con un archivio senza sapere cosa ci sia dentro. È come chiedere «come si apre un file?» senza dire di che file si tratti.

Esempio famoso: Mozilla distribuisce sul suo sito Firefox e Thunderbird (e altri programmi) per sistemi GNU/Linux in archivi .tar.bz2 che contengono dentro i programmi già compilati e pronti per l'uso (una cosa che molta gente sembra non capire, nonostante gli venga detto, è che non c'è bisogno di compilare proprio niente in questo caso). Qui non c'è nulla da installare, per avviare i due programmi basterà scompattare l'archivio (e per favore, se non siete in grado (come me) di farlo da terminale, scompattate attraverso interfaccia grafica, non capisco perché la gente si ammazzi a scompattare da linea di comando quando bastano due clic) e fare doppio clic sul file firefox o thunderbird, a seconda del programma.

Allora la domanda sorgente spontanea: come faccio a capire cosa me ne devo fare di questo archivio? Anche qui la risposta è semplice: aprirlo. Nella stragrande maggioranza dei casi è presente un file chimato README che contiene le istruzioni (purtroppo praticamente sempre in inglese) sul da farsi (estrarre l'archivio e compilare, oppure estrarre e fare doppio clic su un file o altro).

Nel caso in cui l'archivio contenga il sorgente di un programma da compilare è spesso presente anche un altro file chiamato INSTALL che spiega più dettagliatamente come si compila il programma, anche se spesso sono sufficienti i "comandi magici":

./configure
make
# make install

È bene comunque controllare sempre le istruzioni per la compilazione e non partire in quarta con questi comandi, ci sono tantissimi programmi che non devono essere compilati in questo modo.

Concludendo, se avete scaricato un .tar.gz/.bz2/.lzma/ecc. e volete chiedere aiuto su un forum & Co. è sensato porre la domanda «Ho scaricato il programma xyz [magari fornendo anche link al sito da cui si è scaricato l'archivio], come faccio a utilizzarlo?» ma non «Ho scaricato un .tar.gz [senza fornire alcuna indicazione su quale programma si tratti...], come si installa?» perché, come mi sembra di aver già detto,

la domanda non ha senso.

Aprire file system di Wubi da Live CD

2010-05-18T22:19:00.005+02:00

Se avete fatto la sciagurata scelta di installare Ubuntu tramite Wubi e avete incontrato dei problemi che impediscono l'avvio del sistema, potete ancora accedere alla "partizione" di Wubi (anche se il nome "partizione" non è del tutto corretto) usando un Live CD (va bene di qualsiasi distribuzione). Dopo aver avviato il sistema da cd bisogna aprire un terminale, montare la partizione di Windows in cui è installato Wubi (la posizione, in Windows, del file system di Ubuntu dovrebbe essere il file C:\ubuntu\disk\root.disk, o simile). La partizione di Windows può essere anche normalmente montata per via grafica, se possibile (per esempio con GNOME è sufficiente fare clic, in Nautilus, sul nome della partizione desiderata). A questo punto, dare nel terminale i seguenti comandi:

sudo mkdir /vdisk
sudo mount -o loop /media/WINDOWS/ubuntu/disks/root.disk /vdisk

Il primo serve per creare nel sistema live la cartella /vdisk (è comunque possibile dare un percorso e nome arbitrario alla cartella), il secondo per montare il file system di Wubi e usare come punto di montaggio la cartella appena creata. Il penultimo argomento del comando mount è il percorso del file system di Wubi, da adattare al proprio caso: in genere le partizioni si montano nella cartella /media (e così fa in modo predefinito Nautilus, ma è possibile montare in un punto diverso, come infatti faremo) e poi ho scritto WINDOWS che sta a indicare il nome dell'etichetta della partizione (molto probabilmente non sarà questa l'etichetta della partizione, controllate per bene qual è il nome). Per vedere l'elenco delle partizioni montate e relativo punto di montaggio si può dare semplicemente il comando

mount

senza altri argomenti. Il resto del percorso (ubuntu/disk/root.disk) dovrebbe essere corretto (come detto prima, questo è il percorso in cui si dovrebbe trovare il file in Windows). L'autocompletamento nel terminale potrebbe aiutarvi a inserire il percorso corretto.

A questo punto è possibile aprire normalmente il file system di Wubi come una normale partizione montata. Attenti a non fare ulteriori danni all'installazione di Ubuntu, la state già facendo soffrire abbastanza usando Wubi ^^

Avvertenza: se nell'installazione di Wubi si è scelto il file system ext4, per potervi accedere ci sarà bisogno di un Live CD che riconosca questo recente file system. Per esempio, usando Ubuntu ci sarà bisogno del cd della versione 9.04 o successiva.

Questa guida è stata ripresa da https://wiki.ubuntu.com/WubiGuide.

Autocompletamento in Emacs (2)

2010-04-05T19:45:00.004+02:00

Nota: questo post spiega come installare la nuova versione (1.2) dell'estensione auto-complete per Emacs. Le istruzioni per installare la vecchia versione (1.0) si trovano nel post Autocompletamento in Emacs.

In passato avevo spiegato come installare la versione 1.0 dell'estensione auto-complete per l'editor di testo GNU Emacs. Nel frattempo lo sviluppo dell'estensione è andato avanti e ora il programma fornisce delle nuove funzioni che si possono leggere qui. Ora vediamo come installare questa nuova versione (queste istruzioni sono riprese da qui, in lingua inglese).

Per prima cosa è ovviamente necessario scaricare l'estensione. L'ultima versione stabile può essere ottenuta all'indirizzo http://cx4a.org/software/auto-complete/#Latest_Stable (è possibile anche installare una versione di sviluppo da git, ma non spiegherò come farlo in questo post). Nel momento in cui scrivo l'ultima versione stabile è la 1.2 e l'archivio da scaricare si trova all'indirizzo http://cx4a.org/pub/auto-complete/auto-complete-1.2.tar.bz2 (è indifferente scaricare l'archivio .zip o .tar.bz2). Scompattiamo l'archivio e ci spostiamo nel terminale con il comando cd nella cartella appena scompattata. Se per esempio abbiamo scompattato l'archivio in ~/Scrivania (ricordo che la tilde ~ è un'abbreviazione del percorso della home dell'utente corrente) ci dovremo spostare nella cartella ~/Scrivania/auto-complete-1.2 (nelle versioni successive alla 1.2 la cartella cambierà presumibilmente il nome) con il comando

cd ~/Scrivania/auto-complete-1.2

Per installare il l'estensione è sufficiente dare il comando

emacs -batch -l etc/install.el

Alla richiesta

Install to:

dobbiamo inserire il percorso della cartella in cui installare l'estensione. In genere queste estensioni vengono installate in ~/.emacs.d, quindi in questo caso dobbiamo solo scrivere

~/.emacs.d

A questo punto, se l'installazione è andata a buon fine leggeremo il messaggio

Successfully installed!

Add the following code to your .emacs:

(add-to-list 'load-path "~/.emacs.d")
(require 'auto-complete-config)
(add-to-list 'ac-dictionary-directories "~/.emacs.d/ac-dict")
(ac-config-default)

Per poter utilizzare questa estensione dobbiamo infine fare ciò che ci viene detto: aggiungere le stringhe sopraelencate al file ~/.emacs. Per fare ciò apriamo il file suddetto (ricordo che i file e le cartelle che hanno il nome che inizia con il punto sono nascosti) con il nostro editor di testo preferito (per esempio Emacs :D) e aggiungiamo alla fine le stringhe

(add-to-list 'load-path "~/.emacs.d")
(require 'auto-complete-config)
(add-to-list 'ac-dictionary-directories "~/.emacs.d/ac-dict")
(ac-config-default)

La prima serve per aggiungere la cartella ~/.emacs.d alla variabile load-path, che contiene l'elenco delle cartelle in cui vengono cercati i file da caricare. Se la variabile contiene già questa cartella non sarà necessario aggiungerla nuovamente (in Emacs si può vedere il contenuto della variabile load-path con C-h v load-path RET). Se si era installata la vecchia versione di auto-complete è conveniente rimuovere le stringhe precedentemente inserite prima di aggiungere le nuove (anche se alcune coincidono).

Ora esiste anche un sito (in inglese) dedicato a questa estensione, con una ricca documentazione che spiega per esempio come creare nuovi dizionari per determinate major mode di Emacs.

[Risolto] Gnuplot va in crash usando wxt come terminale

2010-02-12T21:50:00.003+01:00

Usando `wxt' come terminale in Gnuplot, famoso programma per disegnare grafici di funzioni matematiche, crasha irrimediabilmente poco dopo che viene rappresentato il grafico (non so se questo problema si presenti solo su Ubuntu o anche su altri sistemi). Il problema si risolve facilmente cambiando terminale, per esempio usando `x11'. Se però preferite usare il più ricco wxt, su Launchpad è stato segnalato (già da un bel po' di tempo) questo workaround: andate in Sistema → Preferenze → Tecnologie assistive e deselezionate l'opzione "Abilitare le tecnologie assistive". Ovviamente questo può essere fatto solo se non si ha bisogno di questo tipo di supporto.

Installare una versione funzionante di Maxima in Ubuntu

2010-01-04T12:00:00.004+01:00

Nota: il problema è ormai risolto dalla versione 10.04 di Ubuntu (Lucid Lynx) in poi. Comunque il repository di Launchpad segnalato permette di avere, in genere entro pochi giorni, l'ultima versione di Maxima e wxMaxima.

Nelle ultime versioni di Ubuntu è disponibile nei repository ufficiali una versione non funzionante del programma di calcolo simbolico e numerico Maxima. Infatti, provando a usare Maxima vi potrebbe capitare ben presto di leggere questi messaggi di errore:

(%i1) atan(x);
Universal error handler called recursively (:ERROR NIL
CONDITIONS::CLCS-UNIVERSAL-ERROR-HANDLER
""
"Couldn't protect")
Universal error handler called recursively (:ERROR NIL
CONDITIONS::CLCS-UNIVERSAL-ERROR-HANDLER
"" "Couldn't protect")
Maxima encountered a Lisp error:

Error in CONDITIONS::CLCS-UNIVERSAL-ERROR-HANDLER [or a callee]: Caught fatal error [memory may be damaged]

Automatically continuing.
To reenable the Lisp debugger set *debugger-hook* to nil.
(%i2) atan(x);
Segmentation fault

Il problema, segnalato su Launchpad nel bug 303587, può essere risolto aggiungendo il repository di blahota. Per fare ciò è sufficiente dare nel terminale il comando

sudo add-apt-repository ppa:blahota/wxmaxima

e il repository sarà anche automaticamente autenticato senza bisogno di ulteriori interazioni.

Questo non è un bug di Maxima ma solo del pacchetto precompilato presente nei repository di Ubuntu, quindi non segnalatelo sul sito di Maxima. Potreste anche provare a compilare da voi Maxima. Se avete un account su Launchpad, non aprite altre segnalazioni ma piuttosto commentate (se ne avete bisogno) il bug segnalato prima e aggiungetevi nell'elenco delle persone affette dal problema.

Nelle ultime versioni di wxMaxima viene usato `wxt' come terminale predefinito per gnuplot, che però va in crash. Un workaround per risolvere il problema può essere trovato qui.

Aggiornamento del 15/02/2010: il bug 303587 sembra che sia stato risolto (riguarda il pacchetto gcl), vedremo se in Lucid sarà presente una versione di Maxima funzionante.

Aprire con Emacs un file protetto

2009-12-24T10:07:00.002+01:00

Se avete l'editor di testo Emacs già aperto e avete necessità di modificare un file di testo protetto (per esempio uno dei file di configurazione presenti nel file system e di proprietà dell'utente root), non c'è bisogno di avviare una nuova sessione Emacs, magari da terminale con il comando

gksudo emacs /percorso/del/file/protetto

Esiste, infatti, una estensione chiamata Tramp (inclusa di default nell'installazione delle ultime versioni di Emacs) che permette di editare file remoti ma anche file appartenenti a un altro utente. Per modificare un file protetto è sufficiente usare la combinazione di tasti C-x C-f (oppure per chi usa l'interfaccia grafica andare in File → Open file, che è la stessa cosa) e scrivere

/sudo::/percorso/del/file/protetto

Quindi, se per esempio vogliamo aggiungere un nuovo repository nel file /etc/apt/sources.list dovremo scrivere

/sudo::/etc/apt/sources.list

Verrà ovviamente richiesta di inserire la password nella echo-area. Se {volete,avete bisogno di,preferite} usare su al posto di sudo, dovete usare la sintassi

/su::/percorso/del/file/protetto

Come accennato prima, Tramp permette anche di modificare file in remoto per esempio attraverso telnet o ssh. La procedura è sempre la stessa: dopo aver aperto un nuovo file con C-x C-f (oppure File → Open file) scrivete

/telnet:/percorso/del/file/remoto

oppure

/ssh:/percorso/del/file/remoto

Per maggiori dettagli su questa estensione potete consultare il manuale (in inglese).

Autocompletamento in Emacs

2009-12-05T19:00:00.007+01:00

Nota: Nel post Autocompletamento in Emacs (2) spiego come installare la nuova versione di questa estensione, che offre maggiori funzionalità rispetto a questa.

In Emacs ("l'editor in tempo reale, estensibile, personalizzabile, auto-documentante e visuale") è disponibile una funzione di autocompletamento con la combinazione M-/ (ricordo che il tasto M, abbreviazione di Meta, corrisponde in genere al tasto Alt oppure Esc). Questa combinazione, però, è abbastanza scomoda da usare dal momento che in realtà bisogna premere 3 tasti ogni volta (ALT + SHIFT + 7, a quanto pare lo slash dell'eventuale tastierino numerico non vale), almeno sulle tastiere italiane, e quindi velocizza ben poco la scrittura di un testo o di un codice. Essendo Emacs un editor di testo estensibile, qualcuno ha ovviamente provveduto a creare un'estensione che permettesse di aumentare notevolmente l'utilità dell'autocompletamento. Esistono almeno 2 o 3 estensioni che fanno al nostro caso, io ne ho provata una in particolare, si chiama Auto Complete.

Come è possibile leggere dal file README visualizzato nella pagina principale del progetto, per installare questa estensione è sufficiente eseguire questi comandi in un terminale (la versione del programma probabilmente cambierà rispetto a quella presente in questo post, fate sempre riferimento al file README presente su quel sito):

git clone git://github.com/m2ym/auto-complete.git
cd auto-complete
git checkout v1.0
emacs -L . -batch -f batch-byte-compile *.el
cp *.el *.elc ~/.emacs.d/

Per seguire questa strada è quindi necessario aver installato nel proprio sistema Git, il sistema software di controllo versione distribuito realizzato da Linus Torvalds in persona. Il nome del pacchetto da installare in Ubuntu per ottenere questo programma (se non è già presente), però, non è git, come ci si potrebbe (e dovrebbe) aspettare ma git-core, perché git si riferisce a un altro programma. Quindi è sufficiente installare da Synaptic il pacchetto git-core, oppure digitare nel terminale il comando

sudo apt-get install git-core

Dopo di ciò sarà possibile eseguire i comandi sopra elencati per poter installare l'estensione Auto Complete. Poi, come spiegato nel file auto-complete.el, bisogna aggiungere al file di configurazione ~/.emacs (ricordo che la tilde ~ è un'abbreviazione per il percorso della cartella home dell'utente corrente e che file e cartelle che hanno il nome che inizia con il punto sono nascosti) queste righe:

(require 'auto-complete)
(require 'auto-complete-config)
(global-auto-complete-mode t)

Queste servono per caricare i file necessari e attivare automaticamente la modalità global-auto-complete.

Potrebbe presentarsi un problema nel caso in cui la cartella ~/.emacs.d non sia presente nella variabile load-path di Emacs. Infatti con l'ultimo comando (cp *.el *.elc ~/.emacs.d/) avete copiato tutti i file con estensione .el e .elc nella cartella ~/.emacs.d, ma in questo caso Emacs non sarebbe in grado di caricare questi file al suo avvio e comparirebbe un messaggio simile a questo:

Warning (initialization): An error occurred while loading `/home/USERN_NAME/.emacs':

File error: Cannot open load file, auto-complete

To ensure normal operation, you should investigate and remove the
cause of the error in your initialization file. Start Emacs with
the `--debug-init' option to view a complete error backtrace.

Per rimediare a ciò è sufficiente aggiungere la cartella in questione alla variabile load-path inserendo questa riga nel file ~/.emacs (prima delle righe segnalate in precedenza, vedi qui):

(add-to-list 'load-path "~/.emacs.d")

A questo punto l'estensione sarà pronta per essere usata.

La procedura di aggiunta di una cartella alla variabile load-path potrebbe essere necessaria anche nel caso in cui si volessero aggiungere altre estensioni presenti in altre cartelle non "caricate" da Emacs. È comunque consigliabile mettere tutte le estensioni personalizzate in un'unica cartella, che può essere tranquillamente diversa da ~/.emacs.d (in questo caso non dimenticatevi di copiare i file dell'estensione Auto Complete nella cartella opportuna!).

PCManFM non riconosce correttamente il tipo del file in Ubuntu Karmic

2009-11-12T22:56:00.008+01:00

Chi sta usando la versione di Ubuntu 9.10 Karmic Koala con ambiente desktop LXDE probabilmente avrà notato che il file manager predefinito, chiamato PCManFM (e la cui versione in questo sistema è la 0.5.1+svn20090607-1), non riconosce correttamente il tipo dei file rendendolo praticamente inutilizzabile. Infatti tutti i file risultano avere come tipo unknown (application/octet-stream) e non è possibile selezionare un'applicazione che apra ciascun file (perché verrebbe utilizzata per aprire tutti file e questo ovviamente non ci sta bene).

Tutto ciò, a quanto pare, è dovuto alla nuova versione (0.70) del pacchetto shared-mime-info. Qualcuno è riuscito a risolvere il problema installando una vecchia versione del pacchetto shared-mime-info (per esempio la 0.60 presente in Jaunty) ma fortunatamente la nuova versione di PCManFM (la 0.5.2) risolve questo problema. Non ci resta quindi che installarla. Ci sono almeno 2 modi per farlo: compilare il sorgente (ma qui non verrà spiegato come farlo) o installare un bel pacchetto deb precompilato. Ovviamente il pacchetto deb precompilato esiste già ed è presente negli archivi di Ubuntu Lucid Lynx (la versione 10.04 che uscirà il prossimo aprile). Per ottenerlo vi basta andare alla pagina http://packages.ubuntu.com/lucid/pcmanfm, selezionare (nella sezione Download pcmanfm) l'architettura usata ("amd64" per il 64-bit, "i386" per il 32-bit) e infine scaricare il deb da uno dei mirror proposti.

Guida introduttiva alla creazione di Makefile per compilare documenti LaTeX

2009-10-17T13:59:00.003+02:00

Per scrivere i miei documenti LaTeX uso un semplice editor di testo e per compilare il documento finale uso il terminale. I comandi da eseguire per compilare un documento devono spesso essere ripetuti più volte e qualche volta trovo di difficile memorizzazione la giusta sequenza delle operazioni. Per semplificarmi la vita ho quindi deciso di rivolgermi a make:

make è una utility usata con i sistemi operativi della famiglia UNIX che automatizza il processo di conversione dei file da una forma ad un'altra, risolvendo le dipendenze e invocando programmi esterni per il lavoro necessario. [...] Esso usa file chiamati "makefiles" per determinare il grafo delle dipendenze per un particolare output, e gli script necessari per la compilazione da passare alla shell.
(http://it.wikipedia.org/wiki/Make)

I Makefile sono estremamente diffusi nell'ambito della programmazione, la maggioranza dei software open-source sfrutta i Makefile per automatizzare la compilazione del programma. La mia idea di utilizzarli anche per compilare documenti LaTeX è tutt'altro che originale, su Internet, infatti, è possibile recuperare numeri sorgenti LaTeX con allegato un Makefile. Esistono dei programmi (essenzialmente degli script) che permettono di compilare correttamente un documento LaTeX con un solo comando, ma preferisco di gran lunga scrivermi da solo un Makefile perché è estremamente flessibile (con cambiamenti minimi può essere adattato a documenti diversi) e perché oltre alla compilazione automatizza anche altri processi come la conversione di immagini nei formati corretti per l'inclusione nel documento finale o la cancellazione dei file temporanei generati nella creazione di quest'ultimo.

Su Internet si trovano numerose guide che spiegano come realizzare Makefile per compilare programmi, ma poco e niente si trova più specificamente per i documenti LaTeX (sebbene il funzionamento di make sia indipendente dall'utilizzo, suppongo che un utente LaTeX non abbia necessariamente le conoscenze necessarie per comprendere una guida rivolta a un programmatore). Per questo motivo già da un po' di tempo (come segnalai sul forum del Gruppo Utilizzatori Italiani di TeX) ho pubblicato una breve guida al riguardo. Il manuale, in formato PDF, lo potete trovare all'indirizzo http://elubuntu.altervista.org/LaTeX/Guide/make.pdf, mentre i sorgenti si trovano all'indirizzo http://elubuntu.altervista.org/LaTeX/Guide/make.tar.gz.

Mi sono concentrato più sui contenuti che sulla forma, infatti in una delle ultime riletture ho trovato svariati errori ortografici, se ne individuate altri segnalate pure. I Makefile che sono illustrati sono relativamente semplici (date le mie conoscenze basilari sull'argomento), ma se ne possono realizzare di molto molto più complessi. Anche in questo caso, se avete consigli, suggerimenti su come ampliare e migliorare la guida siete i benvenuti. La guida è rilasciata con licenza CC-BY, quindi chiunque può modificarlo, adattarlo alle proprie esigenze, ampliarlo (mi farebbe piacere conoscere le modifiche apportate, specie se di ampliamento), a patto di citarne l'autore (cioè io :D).

Avevo intenzione di aggiungere alla guida delle brevi appendici di cui trovate i titoli (provvisori) nel file make.tex dell'archivio, per questo momento però non ho la possibilità di scrivere nulla a riguardo, se mi sarà possibile lo farò fra un po' di tempo.

Plugin per vedere i video di Youtube e Vimeo dentro Pidgin

2009-09-13T15:55:00.003+02:00

Segnalo che poche ore fa è stato rilasciato un plugin molto carino per Pidgin che permette di visualizzare i video presenti su Youtube e Vimeo direttamente all'interno delle finestre di conversazione quando qualcuno linka un video caricato su una di queste due piattaforme, senza bisogno quindi di aprire appositamente un browser. La procedura di installazione è riportata (in inglese) molto chiaramente qui.

Script per vedere canali RAI senza Firefox

2009-09-11T17:20:00.022+02:00

In rete si trovano diversi metodi per Linux che permettono di vedere i canali RAI senza bisogno di dover usare il browser (con conseguente enorme risparmio di memoria). Uno dei migliori (se non il migliore in circolazione) è lo script che si può trovare all'indirizzo http://www.slacky.eu/wikislack/index.php?title=Rai.tv_senza_silverlight. Ultimamente, però, ho problemi ad accedere al sito rai.tv e anche lo scaricamento dei canali effettuati dallo script è particolarmente lento (a volte non avviene proprio perché passano i 10 secondi di timeout impostati nello script. Una soluzione a questo problema è aumentare il timeout, per esempio portandolo a 20 o 30 secondi).

Per evitare di dover aspettare ogni volta diversi secondi per poter avere l'elenco dei canali, allora, ho rimesso mano a un vecchio script che scrissi diversi mesi fa, poco dopo che fu aperto il sito rai.tv, per poter scegliere i canali da vedere ed ecco il risultato (Attenzione: i canali Rai 1, Rai 2 e Rai 3 potrebbero non funzionare):

#!/bin/bash
#  Ultimo aggiornamento: 26/11/2010
#+ Per suggerimenti e consigli visita http://forum.ubuntu-it.org/index.php/topic,316995.0.html

function seleziona(){
    canale=`zenity --list --height=400 --width=300 --title="Televisione" --text="Quale canale vuoi vedere?" --column="Canale" \
    "=== TELEVISIONE ===" "Rai Uno" "Rai Due" "Rai Tre" "Rai 4" "Rai 5" "Rai News 24" "Rai Sport Più" "Rai Sport 2" \
    "Rai Edu1" "Rai Storia" "RaiSat Extra" "RaiSat Premium" "RaiSat Cinema" "RaiSat YoYo" "Rai gulp" "Rai Scuola" "Rai Med" \
    "EuroNews" "Sportitalia" "All Music" "RTL 102.5 (TV)" "NRK1" "NRK2" "NRK Rogaland" "Arcoiris TV" "Antena 1" \
    "France24 English" "etvsatellite" "CBL Channel" "[3]CHANNEL ONE" "SAT 2000" "Ultimo Tg1" "Ultimo Tg2" "Ultimo Tg3" "=== RADIO ===" \
    "Radio Uno" "Radio Due" "Radio Tre" "Isoradio" "RDS" "Radio 105" "RTL 102.5 (Radio)" "Radio Capital" "Radio Deejay" \
    "Radio24" "Controradio" "Radio Popolare" "Radio Onda Rossa" "Radio onda d'Urto" "Radio Città Aperta" "Radio Blackout" \
    "Radio Sherwood" "Virgin radio" "Virgin rock classico" "Virgin rock extreme" "Virgin rock alternative" "Virgin woodstock" \
    "Virgin revolver" "LifeGate Radio" "Radio Flash"`
}

function play_rai(){
    if [ ! -f ~/bin/rai.py ]; then
        if [ ! -d ~/bin ]; then
            mkdir ~/bin
        fi
        wget "http://elubuntu.altervista.org/rai.py" -O ~/bin/rai.py
        chmod +x ~/bin/rai.py
    fi
    ~/bin/rai.py "$1"
}

function play(){
    vlc "$1"
}
while true; do
    seleziona
    case $canale in
        "=== TELEVISIONE ===" | "=== RADIO ===" ) seleziona ;;
        "Rai Uno") play_rai http://mediapolis.rai.it/relinker/relinkerServlet.htm?cont=180090 ;;
        "Rai Due") play_rai http://mediapolis.rai.it/relinker/relinkerServlet.htm?cont=180116 ;;
        "Rai Tre") play_rai http://mediapolis.rai.it/relinker/relinkerServlet.htm?cont=180117 ;;
        "Rai 4") play_rai http://mediapolis.rai.it/relinker/relinkerServlet.htm?cont=75708 ;;
        "Rai 5") play_rai http://mediapolis.rai.it/relinker/relinkerServlet.htm?cont=72382 ;;
        "Rai News 24") play_rai http://mediapolis.rai.it/relinker/relinkerServlet.htm?cont=1 ;;
        "Rai Sport Più") play_rai http://mediapolis.rai.it/relinker/relinkerServlet.htm?cont=4145 ;;
        "Rai Sport 2") play_rai http://mediapolis.rai.it/relinker/relinkerServlet.htm?cont=179975 ;;
        "Rai Edu1") play_rai http://mediapolis.rai.it/relinker/relinkerServlet.htm?cont=24268 ;;
        "Rai Storia") play_rai http://mediapolis.rai.it/relinker/relinkerServlet.htm?cont=24269 ;;
        "RaiSat Extra") play_rai http://mediapolis.rai.it/relinker/relinkerServlet.htm?cont=72382 ;;
        "RaiSat Premium") play_rai http://mediapolis.rai.it/relinker/relinkerServlet.htm?cont=72916 ;;
        "RaiSat Cinema") play_rai http://mediapolis.rai.it/relinker/relinkerServlet.htm?cont=72381 ;;
        "RaiSat YoYo") play_rai http://mediapolis.rai.it/relinker/relinkerServlet.htm?cont=72918 ;;
        "Rai gulp") play_rai http://mediapolis.rai.it/relinker/relinkerServlet.htm?cont=4119 ;;
        "Rai Scuola") play_rai http://mediapolis.rai.it/relinker/relinkerServlet.htm?cont=24268 ;;
        "Rai Med") play_rai http://mediapolis.rai.it/relinker/relinkerServlet.htm?cont=87127 ;;
        "EuroNews") play_rai http://mediapolis.rai.it/relinker/relinkerServlet.htm?cont=113784 ;;
        "Sportitalia") play mms://mms.cdn-tiscali.com/sportitalia ;;
        "All Music") play mms://live.mediaserver.kataweb.it/retea?MSWMExt=.asf ;;
        "RTL 102.5 (TV)") play mms://151.1.245.36/rtl102.5vs ;;
        "NRK1") play mms://mms-icanal-live.online.no/nrk_tv_webvid03_l ;;
        "NRK2") play mms://mms-icanal-live.online.no/nrk_tv_webvid05_h ;;
        "NRK Rogaland") play mms://straumV.nrk.no/nrk_tv_rogaland_247_mbr ;;
        "Arcoiris TV") play mms://193.41.7.40/vive-adsl ;;
        "Antena 1") play mms://81.196.2.232/pp1 ;;
        "France24 English") play mms://stream1.france24.yacast.net/f24_liveen ;;
        "etvsatellite") play mms://streaming.e-tv.it/etvsatellite ;;
        "CBL Channel") play mms://151.1.245.71/cblfilm-live ;;
        "[3]CHANNEL ONE") play mms://84.233.254.2/3Channel ;;
        "SAT 2000") play mms://89.119.94.130/Sat2000 ;;
        "Ultimo Tg1") play http://link.rai.it/x/vod/ue/wmx/ultimo_tg1.asx ;;
        "Ultimo Tg2") play http://link.rai.it/x/vod/ue/wmx/ultimo_tg2.asx ;;
        "Ultimo Tg3") play http://link.rai.it/x/vod/ue/wmx/ultimo_tg3.asx ;;
        "Radio Uno") play rtsp://live.media.rai.it/broadcast/radiouno.rm ;;
        "Radio Due") play rtsp://live.media.rai.it/broadcast/radiodue.rm ;;
        "Radio Tre") play rtsp://live.media.rai.it/broadcast/radiotre.rm ;;
        "Isoradio") play rtsp://live.media.rai.it/broadcast/isoradio.rm ;;
        "RDS") play mms://fastreal.fastweb.it/RDS ;;
        "Radio 105") play mms://151.1.245.6/1 ;;
        "RTL 102.5 (Radio)") play mms://151.1.245.36/rtl102.5hq/ ;;
        "Radio Capital") play mms://live.mediaserver.kataweb.it/capital?MSWMExt=.asf ;;
        "Radio Deejay") play mms://live.mediaserver.kataweb.it/radiodeejay?MSWMext=.asf ;;
        "Radio24") play mms://62.196.2.90/Radio24 ;;
        "Controradio") play http://streaming.controradio.emmi.it:8190/ ;;
        "Radio Popolare") play http://www.radiopopolare.it/liveU.asx ;;
        "Radio Onda Rossa") play http://radio.dyne.org:8000/ondarossa.mp3 ;;
        "Radio onda d'Urto") play http://www.radiondadurto.org:8000/listen.pls ;;
        "Radio Città Aperta") play mms://stream.greynetweb.it/rca?MSWMExt=.asf ;;
        "Radio Blackout") play http://stream.teknusi.org:8000/blackout.mp3 ;;
        "Radio Sherwood") play http://62.101.68.185:8000/sherwood.ogg ;;
        "Virgin radio") play mmsh://151.1.245.1/20?MSWMExt=.asf ;;
        "Virgin rock classico") play mms://151.1.245.1/24 ;;
        "Virgin rock extreme") play mms://151.1.245.1/25 ;;
        "Virgin rock alternative") play mms://151.1.245.1/36 ;;
        "Virgin woodstock") play mms://151.1.245.1/13 ;;
        "Virgin revolver") play mms://151.1.245.1/34 ;;
        "LifeGate Radio") play mmsh://onair8.xdevel.com/Lifegate?MSWMExt=.asf ;;
        "Radio Flash") play http://stream5.top-ix.it:8000/radioflash.m3u ;;
        *) exit 0 ;;
    esac
done

(Lo trovate anche qui: http://forum.ubuntu-it.org/index.php/topic,316995.0.html) Gli unici pacchetti richiesti per l'utilizzo del programma sono zenity (utilizzato per creare la semplice interfaccia di scelta del programma) e vlc (potente player multimediale che permette di modificare l'user agent HTTP, necessario per accedere ai video presenti su rai.tv). Per visualizzare i canali della RAI inoltre è necessario installare python3.

Per utilizzarlo basta copiare lo script in un file con un editor di testo a piacere, salvare il file chiamandolo, per esempio, rai, renderlo eseguibile e posizionarlo nella cartella ~/bin (ricordo che la tilde ~ è un'abbreviazione della cartella home dell'utente corrente), creandola se eventualmente non esiste. All'avvio successivo del computer dovrebbe essere sufficiente dare nel terminale il comando

rai

(o il nome che avete dato allo script) per poter aprire la finestra di scelta del canale da visualizzare. Ovviamente è anche possibile creare un lanciatore a questo comando per avviarlo ancora più semplicemente.

Questo script permette solo di vedere le dirette elencate nella finestra che vi apparirà, lo script presente su slacky.eu, invece, offre la possibilità di riprodurre anche tanti altri video presenti sul sito della RAI.

Aggiornamento: su suggerimento di mario000 ho aggiunto anche il link allo streaming di Sportitalia. Se avete suggerimenti per altri canali da aggiungere (anche radio se volete), non esitate a segnalare (meglio se forniti di link allo streaming :-) ). D'ora in poi non credo che scriverò tutte le modifiche apportate allo script, se non modifiche importanti.

Rendere eseguibile un file

2009-09-01T20:18:00.006+02:00

Affinché un file possa essere eseguito è necessario che abbia impostato il permesso di esecuzione. Infatti, provando a eseguire da terminale un file (sia esso un eseguibile, uno script o altro) che non ha il permesso di esecuzione riceverete il messaggio di errore:

bash: ./nomefile: Permesso negato

(dove nomefile rappresenta il nome del file che si è provato a eseguire).

Per impostare il permesso di esecuzione da terminale bisogna utilizzare il comando chmod. La sintassi del comando è

chmod [OPZIONI] permessi nomefile

Per quello che vi interessa riguardo al rendere eseguibile un file il comando da utilizzare è

chmod +x nomefile

Il file da rendere eseguibile può essere specificato indicandone il percorso assoluto o quello relativo, come preferite. Per tutti gli altri usi e opzioni di chmod potete consultare il manuale utilizzando il solito comando man chmod.

Ovviamente è possibile rendere eseguibile un file utilizzando l'interfaccia grafica. Se usate Nautilus, il file manager predefinito di GNOME, bisogna fare clic con il tasto destro sull'icona di un file, scegliere Proprietà, nella scheda Permessi si deve quindi mettere la spunta a Consentire l'esecuzione del file come programma.

È possibile anche utilizzare il seguente breve script di Nautilus che ho scritto per rendere eseguibile anche più file contemporaneamente con un solo clic:

#!/bin/bash
for arg; do
    chmod u+x -- "$arg"
done

Per utilizzare lo script, aprite un file vuoto con un editor di testo (come gedit), copiate lo script nell'editor e salvatelo nella cartella ~/.gnome2/nautilus-scripts (ricordo che la tilde ~ è un'abbreviazione della cartella home dell'utente corrente) chiamandolo, per esempio, Rendi eseguibile. Rendete quindi eseguibile lo script in uno dei modi descritti in precedenza. In questo modo, selezionando e facendo clic con il tasto destro sui file a cui vorrete assegnare il permesso di esecuzione, vi basterà fare clic su Script → Rendi eseguibile (o il nome che avete dato allo script).

Rimuovere conferma per il termine sessione, riavvio e arresto del computer

2009-08-31T14:57:00.006+02:00

Probabilmente dalla versione 9.04 di Ubuntu avrete notato che facendo clic sulle opzioni Termina sessione..., Sospendi, Iberna, Riavvia... e Arresta... dall'Applet Selettore rapido utente (l'applet che si trova in genere sull'estrema destra del pannello superiore in GNOME) viene chiesta una conferma.

Se si vuole modificare questo comportamento è sufficiente fare clic con il tasto destro sull'applet, scegliere Preferenze e togliere la spunta all'opzione Confermare il termine sessione, riavvio e arresto del computer.

Aggiungere colonne con tag ID3 e informazioni Exif in Nautilus

2009-08-30T23:02:00.009+02:00

Per sopperire alla mancanza in Nautilus (il file manager predefinito di GNOME) delle colonne con i tag ID3 (per i file musicali mp3) e le informazioni Exif (per le fotografie scattate dalle fotocamere digitali), è possibile utilizzare lo script scritto in python che potete trovare sul forum internazionale di Ubuntu all'indirizzo questo indirizzo. Per scaricare direttamente lo script potete fare clic qui.

Non so se esistano soluzioni migliori, comunque questo metodo è abbastanza efficiente. Come potete leggere dai primi commenti all'interno dello script, per utilizzarlo è necessario installare i pacchetti python-nautilus, python-mutagen e python-pyexiv2. Questi pacchetti possono essere facilmente installati da Synaptic, oppure da terminale con il comando

sudo apt-get install python-nautilus python-mutagen python-pyexiv2

Dopo di ciò bisogna spostare lo script all'interno della cartella ~/.nautilus/python-extensions (ricordo che la tilde ~ è un'abbreviazione del percorso della home dell'utente corrente e che le cartelle che hanno il nome che inizia con il punto sono cartelle nascoste, bisogna quindi premere [ CTRL ] + [ H ] per visualizzarle). Se la cartella non esiste bisogna ovviamente crearla (la cartella ~/.nautilus dovrebbe comunque esistere già, sarà al massimo necessario creare la sottocartella). Alternativamente, lo script potrebbe anche essere posto in /usr/lib/nautilus/extensions-2.0/python/, è necessario però agire da super utente per posizionare lo script in quella cartella.

Prima di poter utilizzare lo script bisogna renderlo eseguibile: fate clic con il tasto destro sull'icona dello script, fate clic su Proprietà e nella scheda Permessi della finestra che si aprirà mettete la spunta a Consentire l'esecuzione del file come programma.

Per concludere riavviate Nautilus (riavviando il computer oppure terminando la sessione corrente oppure digitando il comando killall nautilus (quest'ultima opzione personalmente la preferisco di meno)). Al successivo avvio di Nautilus, utilizzando la vista a elenco, potrete aggiungere le colonne contenti le informazioni che vi servono (Visualizza → Colonne visibili). I nomi delle colonne sono in inglese, ma si capisce facilmente cosa c'è scritto (modificando un poco lo script si potrebbero tradurre i nomi delle colonne in italiano, ma non conoscendo il python non sono in grado di dire cosa va corretto).

Ottenere informazioni sull'hardware del sistema

2009-08-27T19:17:00.005+02:00

Per ottenere informazioni abbastanza dettagliata sull'hardware presente sul proprio computer si può utilizzare il comando da terminale

sudo lshw

(è necessario lanciare il comando con i diritti da superutente altrimenti si otterrebbero delle informazioni parziali.) lshw dovrebbe essere già installato nel vostro sistema operativo Ubuntu, in caso contrario è sufficiente installare il pacchetto omonimo da Synaptic o da terminale con il comando

sudo apt-get install lshw

Questo programma attualmente supporta DMI (solo x86 e IA-64), OpenFirmware device tree (solo PowerPC), PCI/AGP, CPUID (x86), IDE/ATA/ATAPI, PCMCIA (testato solo su x86), SCSI e USB, non vengono però rilevati dispositivi Firewire(IEEE1394), non tutte le architetture supportate da GNU/Linux sono supportate da lshw e le interfacce "Virtual" SCSI usate per l'emulazione SCSI su IDE non sono ancora riportate correttamente (tutte queste informazioni riguardo a lshw che ho snocciolato capendoci più o meno qualcosa le potete ottenere semplicemente leggendo il manuale di lshw dando il comando man lshw nel terminale).

Oltre a questo comando è possibile utilizzare i comandi

lsusb

lspci

per ottenere informazioni sui dispositivi connessi rispettivamente a porte USB e PCI. L'ultimo comando in particolare può essere utilizzato, generalmente, per conoscere il modello della propria scheda video. Se l'output del comando risulta molto lungo si può restringere l'output alle sole stringhe contenenti la parola VGA in questo modo:

lspci | grep VGA

(è, per esempio, necessario conoscere il modello della propria scheda video per installare il driver).

Accanto ai programmi appena visti, che dispongono solo di un'interfaccia a linea di comando, esistono anche alcuni programmi con interfaccia grafica. Fra questi possiamo ricordare lshw-gtk e hardinfo, entrambi installabili nelle solite maniere dai repository ufficiali di Ubuntu.

Lshw-gtk non è altro un'interfaccia del precedentemente esposto lshw (anche in questo caso si dovrebbe avviare il comando da root per ottenere le informazioni complete, quindi lanciandolo da terminale con il comando sudo lshw-gtk).

Hardinfo è una semplice e utile applicazione per avere sotto controllo le informazioni “tecniche” del sistema e per effettuare qualche benchmark prestazionale. Per avviare il programma è sufficiente dare il comando hardinfo nel terminale. Le informazioni che si possono ottenere sul sistema attraverso hardinfo sono:
- Informazioni inerenti l’hardware del computer:
* Sistema operativo
* Moduli del kernel
* Avvii
* Localizzazione
* Filesystem
* Display
* Variabili d'ambiente
* Utenti
- Dispositivi:
* Processore
* Memoria
* Dispositivi PCI
* Dispositivi USB
* Stampanti
* Batteria
* Sensori (temperatura, voltaggi, velocità delle ventole ecc)
* Dispositivi di input
* Memorie di massa
* DMI
* Risorse
- Informazioni sulla rete:
* Interfacce
* Connessioni IP
* Tabella di routing
* Tabella ARP
* Server DNS
* Statistiche
* Cartelle condivise
- Benchmark:
* Blowfish
* CryptoHash
* Fibonacci
* N-Queens
* FPU Raytracing
* FFT
I risultati dei benchmark vengono confrontati con quelli ottenuti attraverso altre macchine.

Questo post è pubblicato sotto la Licenza Creative Commons Attribuzione-Non commerciale-Condividi allo stesso modo.

Alcune parti di questo post sono state riprese da http://netjack.wordpress.com/2006/12/12/hardinfo-informazioni-di-sistema-e-benchmark-a-potata-di-click/ e http://webupd8.blogspot.com/2009/05/2-open-source-alternatives-to-everest.html

Aggiungere pacchetti per LaTeX

2009-08-03T14:52:00.004+02:00

Se vuoi subito scoprire come installare pacchetti per LaTeX vai direttamente al riepilogo, se invece vuoi leggere le mie (tutto sommato inutili) peripezie per aggiungere un pacchetto puoi leggere tutto il post.

Da un po' di tempo mi sto dilettando a scrivere testi con LaTeX. Qualche giorno fa avevo la necessità di installare un nuovo pacchetto LaTeX, per la precisione il pacchetto empheq. Ho dovuto navigare un po' su Internet prima di trovare la soluzione, mettendo insieme varie guide trovate in giro. Per altro, alla fine del mio peregrinare ho scoperto che avrei potuto molto più facilmente installare (per esempio da Synaptic) in Ubuntu il pacchetto texlive-latex-extra che fornisce poco meno di 500 pacchetti LaTeX (qui potete leggere l'elenco dei pacchetti forniti nella versione presente in Ubuntu Jaunty).

In attesa di vedere in un futuro non troppo lontano in Ubuntu la versione 2008 della distribuzione TeX Live, con cui pare sia molto semplice installare nuovi pacchetti LaTeX (anche quelli non presenti in texlive-latex-extra), spiegherò come ho fatto.

La guida che ho seguito inizialmente è stata http://www.guit.sssup.it/installazione/pacchetti.php. Per prima cosa, per installare un nuovo pacchetto, è necessario ovviamente scaricarlo. Nel mio caso, per ottenere il pacchetto empheq ho scaricato l'archivio http://theory.uwinnipeg.ca/scripts/CTAN/macros/latex/contrib/mh.zip. L'ho scompattato e ho compilato il file empheq.dtx in modo da ottenere il file empheq.sty. Il problema che sorgeva a questo punto era posizionare il pacchetto in una cartella in cui LaTeX sarebbe stato in grado di trovarlo. Infatti, compilando un sorgente LaTeX che includeva empheq ottenevo il seguente messaggio di errore:

! LaTeX Error: File `empheq.sty' not found.

In realtà, compilando il sorgente da terminale, quando compare questo messaggio di errore è possibile inserire il percorso del pacchetto, ma ovviamente questa non è una soluzione molto pratica. Una cartella in cui si potrebbero inserire i pacchetti affinché LaTeX sia in grado di utilizzarli è /usr/share/texmf/tex/latex/, ma personalmente preferisco per svariati motivi salvare queste cose all'interno della home (anche per evitare ogni volta di dover diventare root per aggiungere o modificare un pacchetto). Sul forum GUIT avevo letto che per sapere qual è la cartella in cui salvare il pacchetto bisogna dare nel terminale il seguente comando

kpsexpand '$TEXMFHOME'

che mi ha restituito come output

/home/luke/texmf

Ho quindi spostato il pacchetto nella cartella indicata (che ho creato perché non esisteva) e provato a ricompilare il sorgente però ricevendo sempre il precedente messaggio di errore. Con un po' di fortuna ho trovato un altro comando per trovare le cartelle in cui salvare i pacchetti:

kpsepath tex

che ha restituito questo output un po' illeggibile:

.:/home/luke/.texmf-config/tex/kpsewhich//:/home/luke/.texmf-var/tex/kpsewhich//:/home/luke/texmf/tex/kpsewhich//:/etc/texmf/tex/kpsewhich//:!!/var/lib/texmf/tex/kpsewhich//:!!/usr/local/share/texmf/tex/kpsewhich//:!!/usr/share/texmf/tex/kpsewhich//:!!/usr/share/texmf-texlive/tex/kpsewhich//:/home/luke/.texmf-config/tex/generic//:/home/luke/.texmf-var/tex/generic//:/home/luke/texmf/tex/generic//:/etc/texmf/tex/generic//:!!/var/lib/texmf/tex/generic//:!!/usr/local/share/texmf/tex/generic//:!!/usr/share/texmf/tex/generic//:!!/usr/share/texmf-texlive/tex/generic//:/home/luke/.texmf-config/tex///:/home/luke/.texmf-var/tex///:/home/luke/texmf/tex///:/etc/texmf/tex///:!!/var/lib/texmf/tex///:!!/usr/local/share/texmf/tex///:!!/usr/share/texmf/tex///:!!/usr/share/texmf-texlive/tex///

È un elenco che utilizza i due punti come separatore fra le cartelle (più qualche punto esclamativo messo con non so quale criterio). Per renderlo un po' più comprensibile ho utilizzato 3 pipe che restringessero inoltre il campo alle cartelle contenute nella home:

kpsepath tex | sed 's/:/\n/g' | tr -d '!' | grep home

con questo output:

/home/luke/.texmf-config/tex/kpsewhich//
/home/luke/.texmf-var/tex/kpsewhich//
/home/luke/texmf/tex/kpsewhich//
/home/luke/.texmf-config/tex/generic//
/home/luke/.texmf-var/tex/generic//
/home/luke/texmf/tex/generic//
/home/luke/.texmf-config/tex///
/home/luke/.texmf-var/tex///
/home/luke/texmf/tex///

In particolare ha attirato la mia attenzione l'ultima cartella, /home/luke/texmf/tex/ (lasciate stare gli slash in più alla fine dei percorsi). Ho quindi creato la cartella /home/luke/texmf/tex/ e spostato nuovamente il pacchetto empheq.sty in questa cartella. Provando a ricompilare il sorgente però continuavo a ricevere sempre lo stesso errore che segnala pacchetto non trovato. Nella guida http://wiki.ubuntu-it.org/Ufficio/Latex ho letto che per aggiornare l'elenco dei pacchetti era necessario dare il comando

sudo texhash

Leggendo però il manuale del comando (nel terminale: man texhash) ho scoperto che quel comando non aggiorna l'elenco dei pacchetti contenuti nella home. Per fare ciò bisogna dare quindi il comando

texhahs ~/texmf

(ricordo che la tilde ~ è un'abbreviazione del percorso della home dell'utente corrente) e finalmente sono riuscito a compilare il sorgente.

Riepilogo delle operazioni da fare: scaricare il pacchetto e posizionare il file .sty nella cartella ~/texmf/tex (ovviamente creandola se non esiste). Se nell'archivio che si è scaricato non è presente un file .sty ma un .ins o un .dtx bisogna compilare questi file per ottenere il .sty, come spiegato qui. Quindi bisogna aggiornare l'elenco dei pacchetti LaTeX presenti nella cartella con il comando

texhash ~/texmf

e si può finalmente compilare il sorgente che include il nuovo pacchetto.

In realtà sarebbe sufficiente anche inserire il pacchetto nella stessa cartella in cui si trova il sorgente senza dover usare ulteriori comandi, ma trovo questa soluzione poco pratica nel caso in cui si dovessero avere sorgenti LaTeX in numerose cartelle diverse.

Precisazione del 18/8/2009: rileggendo con più attenzione di quanto non avessi fatto inizialmente la guida http://www.guit.sssup.it/installazione/pacchetti.php mi sono accorto che c'era scritto:

copiare il relativo file .sty nella sotto-cartella /tex/latex/ di uno dei tre alberi (eventualmente creando tale sotto-cartella, se non ci fosse già);

Quindi senza perdere tutto il tempo che ho perso avrei potuto subito notare che era necessario mettere i pacchetti nella sottocartella tex/latex/ di ~/texmf (in realtà a me funziona anche solo con tex/, non ho avuto bisogno di creare anche la sottocartella latex/). Resta comunque valido il procedimento descritto nel riepilogo.

Compilare QtOctave 0.8.2

2009-07-22T21:30:00.008+02:00

Dopo aver compilato GNU Octave 3.2.2 ho compilato un programma che fornisce un'interfaccia grafica per Octave: QtOctave. La versione che ho scaricato è l'ultima disponibile a oggi, la 0.8.2, rilasciata poche settimane dopo la versione 3.2 di GNU Octave.

Anche in questo caso consiglio a chi non può o non vuole compilare questi programmi di scaricare i pacchetti precompilati per Ubuntu di Octave 3.2 + QtOctave 0.8.2 dal sito http://tobal.cymaho.com/?p=920.

L'URL per scaricare i sorgenti di QtOctave può essere trovato a questo indirizzo: http://qtoctave.wordpress.com/download/, in particolare la versione che ho scaricato si ottiene da http://forja.rediris.es/frs/download.php/1383/qtoctave-0.8.2.tar.gz. Scompattate l'archivio in una cartella, aprite un terminale (Applicazioni → Accessori → Terminale) e spostatevi (nel terminale con il comando cd) nella cartella in cui avete scompattato il sorgente. Se per esempio è la cartella ~/Scrivania/qtoctave-0.8.2 (ricordo che la tilde ~ è l'abbreviazione della home dell'utente corrente) dovete dare il comando

cd ~/Scrivania/qtoctave-0.8.2

Come per ogni compilazione, è necessario installare i compilatore, che si ottengono installando il pacchetto build-essential. Questo può essere installato da Synaptic, oppure da terminale con il comando

sudo apt-get install build-essential

Dopo di ciò bisogna installare i pacchetti necessari per la compilazione di QtOctave con il comando

sudo apt-get build-dep qtoctave

Nel file readme.txt che si trova nella cartella dei sorgenti spiega che bisogna inoltre installare le librerie Qt e i pacchetti di sviluppo Qt, dalla versione 4.5.0 in poi. È sufficiente installare il pacchetto libqt4-dev , tutti le dipendenze verranno installate automaticamente. Inoltre bisogna installare il pacchetto cmake. Senza aver installato le librerie Qt sarebbe comparso il seguente messaggio di errore in fase di compilazione:

CMake Error at /usr/share/cmake-2.6/Modules/FindQt4.cmake:1472 (MESSAGE):
Qt qmake not found!
Call Stack (most recent call first):
CMakeLists.txt:22 (FIND_PACKAGE)

-- Configuring incomplete, errors occurred!

A questo punto, nel file readme.txt viene consigliato di creare una cartella chiamata build ed eseguire una serie di comandi elencati. In questo modo, però, ho rilevato numeri errori in fase di compilazione di questo tipo:

[ 44%] Building CXX object easy_plot/src/CMakeFiles/easy_plot.dir/main.o
In file included from /home/luke/qtoctave-0.8.2/easy_plot/src/main.cpp:3:
/home/luke/qtoctave-0.8.2/easy_plot/src/main_window.h:7:35: error: ui_design_main_window.h: Nessun file o directory
/home/luke/qtoctave-0.8.2/easy_plot/src/main_window.h:9:27: error: ui_view_angle.h: Nessun file o directory
In file included from /home/luke/qtoctave-0.8.2/easy_plot/src/main.cpp:3:
/home/luke/qtoctave-0.8.2/easy_plot/src/main_window.h:11: error: ‘Ui’ is not a namespace-name
/home/luke/qtoctave-0.8.2/easy_plot/src/main_window.h:11: error: expected namespace-name before ‘;’ token
/home/luke/qtoctave-0.8.2/easy_plot/src/main_window.h:18: error: ‘Ui_DesignMainWindow’ does not name a type
/home/luke/qtoctave-0.8.2/easy_plot/src/main_window.h:21: error: ISO C++ forbids declaration of ‘Ui_ViewAngle’ with no type
/home/luke/qtoctave-0.8.2/easy_plot/src/main_window.h:21: error: expected ‘;’ before ‘*’ token
make[2]: *** [easy_plot/src/CMakeFiles/easy_plot.dir/main.o] Errore 1
make[1]: *** [easy_plot/src/CMakeFiles/easy_plot.dir/all] Errore 2
make: *** [all] Errore 2

Oltre a questo mi sono comparsi altri errori simili. Li ho risolti copiando gli header file che vengono segnalati come mancanti da una sottocartella della cartella build creata, nella cartella in cui si trovano i sorgenti che compaiono nei messaggi di errore. Sono comunque riuscito a evitare tutto ciò nel seguente modo: dopo aver installato i pacchetti sopra elencati ho dato nel terminale (posizionato nella cartella in cui ho scompattato l'archivio) il comando

cmake .

(notate il punto dopo cmake che shell bash rappresenta un'abbreviazione della cartella corrente, infatti il comando cmake richiede come argomento la cartella in cui si trova un sorgente. Per maggiori informazioni consultate il manuale) a differenza di quanto spiegato nel file readme.txt (AGGIORNAMENTO: mi sono accorto che questa è proprio la procedura descritta in leeme.txt, forse l'autore si è dimenticato di aggiornare anche il file in lingua inglese). Poi ho proseguito con il comando

make

Dopo il make, per installare il programma si dovrebbe dare il comando

sudo make install

ma anche in questo caso ho preferito creare un pacchetto deb con e checkinstall. Per creare il pacchetto, senza installarlo, ho dato il comando

sudo checkinstall --install=no

Successivamente ho installato il pacchetto deb che è stato creato.

Aggiornamento: in questa discussione sul forum di Ubuntu ho aiutato a compilare QtOctave 0.8.2 l'utente simo2777, che però ha riscontrato qualche problema in più rispetto a me. Riporto qui gli errori e le soluzioni per completezza.
Primo problema:

[ 40%] Building CXX object easy_plot/src/CMakeFiles/easy_plot.dir/gnuplot_connection.o
/home/simone/Programmi/qtoctave-0.8.2/easy_plot/src/gnuplot_connection.cpp: In member function ‘void GnuplotConnection::standardOutputReady()’:
/home/simone/Programmi/qtoctave-0.8.2/easy_plot/src/gnuplot_connection.cpp:143: error: ‘printf’ was not declared in this scope
make[2]: *** [easy_plot/src/CMakeFiles/easy_plot.dir/gnuplot_connection.o] Errore 1
make[1]: *** [easy_plot/src/CMakeFiles/easy_plot.dir/all] Errore 2
make: *** [all] Errore 2

Soluzione (solo per il primo errore, per il successivo leggi più avanti): installare le dipendenze di qtoctave con il comando sudo apt-get build-dep qtoctave e (se non già presente) il pacchetto gnuplot con il comando sudo apt-get install gnuplot.
Secondo problema:

[ 43%] Building CXX object easy_plot/src/CMakeFiles/easy_plot.dir/gnuplot_connection.o
/home/simone/Programmi/qtoctave-0.8.2/easy_plot/src/gnuplot_connection.cpp: In member function ‘void GnuplotConnection::standardOutputReady()’:
/home/simone/Programmi/qtoctave-0.8.2/easy_plot/src/gnuplot_connection.cpp:143: error: ‘printf’ was not declared in this scope
make[2]: *** [easy_plot/src/CMakeFiles/easy_plot.dir/gnuplot_connection.o] Errore 1
make[1]: *** [easy_plot/src/CMakeFiles/easy_plot.dir/all] Errore 2
make: *** [all] Errore 2

Soluzione (trovata qui): includere nel file easy_plot/src/gnuplot_connection.cpp l'header cstdio, per esempio in questo modo:

#include <QXmlStreamReader>
#include <QXmlStreamWriter>
#include <QHash>
#include <cstdio>

GnuplotConnection::GnuplotConnection(QObject *parent):QProcess(parent)

Terzo problema (simile a quello precedente):

[ 75%] Building CXX object qtoctave/src/CMakeFiles/qtoctave.dir/search_dialog.o
/home/simone/Programmi/qtoctave-0.8.2/qtoctave/src/search_dialog.cpp: In destructor ‘virtual SearchDialog::~SearchDialog()’:
/home/simone/Programmi/qtoctave-0.8.2/qtoctave/src/search_dialog.cpp:96: error: ‘printf’ was not declared in this scope
make[2]: *** [qtoctave/src/CMakeFiles/qtoctave.dir/search_dialog.o] Errore 1
make[1]: *** [qtoctave/src/CMakeFiles/qtoctave.dir/all] Errore 2
make: *** [all] Errore 2

Soluzione: come prima, includere l'header cstdio nel file
qtoctave/src/search_dialog.cpp aggiungendo la riga

#include <cstdio>

all'inizio.

Compilare GNU Octave 3.2.2

2009-07-22T16:05:00.012+02:00

Nota: all'indirizzo http://elubuntu.blogspot.com/2011/02/compilare-gnu-octave-340.html trovate una guida su come compilare GNU Octave 3.4.0.

In Ubuntu 9.04 è presente ancora una versione non nuovissima di GNU Octave e avrei voluto scrivere come ho compilato GNU Octave 3.2, ma proprio oggi è uscita la più recente versione del programma di analisi numerica, ottimo sostituto open-source di Matlab, e quindi spiegherò come ho compilato GNU Octave 3.2.2 (l'ho testato su Ubuntu Jaunty Jackalope, su versioni precedenti del sistema potrebbero mancare troppi pacchetti necessari all'installazione del programma).

Avviso già da adesso, che ci non vuole provare l'"ebbrezza" di compilare da solo questo programma ma preferisce installare direttamente i pacchetti .deb, può scaricare da qui un archivio contenente tutto ciò che serve (sono presenti i pacchetti di Octave 3.2, dell'interfaccia grafica QtOctave e le varie dipendenze che sono necessarie). L'archivio l'ho trovato a questo indirizzo. http://tobal.cymaho.com/?p=920. Questa soluzione potrebbe essere preferita anche da chi non ha intenzione o la possibilità di scaricare diversi megabyte (credo poche centinaia) di pacchetti assortititi che occuperanno molto spazio sull'hard disk dopo l'installazione.

Per prima cosa, ovviamente, serve il sorgente: lo trovate nella pagina dei download di Octave, l'indirizzo del sorgente è ftp://ftp.octave.org/pub/octave/octave-3.2.2.tar.gz. Scaricate l'archivio e scompattatelo in una cartella (ricordatevi per bene il nome della cartella in cui l'avete salvato). Da questo momento in poi sarà necessario usare (quasi) sempre il terminale, quindi apritene uno (Applicazioni → Accessori → Terminale) e spostatevi (nel terminale con il comando cd) nella cartella in cui avete scompattato il sorgente. Se per esempio è la cartella ~/Scrivania/octave-3.2.2 (ricordo che la tilde ~ è l'abbreviazione della home dell'utente corrente) dovete dare il comando

cd ~/Scrivania/octave-3.2.2

sudo apt-get install build-essential

Dopo di ciò bisogna installare i pacchetti necessari per la compilazione di Octave: il comando

sudo apt-get build-dep octave3.0

installerà la maggior parte dei pacchetti che serviranno, ma non tutti (il comando build-dep di apt-get recupera i pacchetti necessari per la compilazione del pacchetto specificato ma qualcuno potrebbe sfuggire, come in questo caso). L'usuale procedura per la compilazione del sorgente di un programma prevedere che a questo punto venga dato il comando

./configure

(esegue il programma configure, quindi assicuratevi di essere nella cartella corretta). La prima volta che ho eseguito il configure, alla fine ho ricevuto questo elenco di avvisi:

configure: WARNING: I didn't find bison, but it's only a problem if you need to reconstruct parse.cc
configure: WARNING: qrupdate not found. The QR & Cholesky updating functions will be slow.
configure: WARNING: arpack not found. This will result in a lack of the eigs function.
configure: WARNING: GraphicsMagick++ config script not found. Assuming GraphicsMagic++ library and header files are missing, so imread will not be fully functional
configure: WARNING: "FLTK config script not found. Native graphics will be disabled."
configure: WARNING:
configure: WARNING: I didn't find the necessary libraries to compile native
configure: WARNING: graphics. It isn't necessary to have native graphics
configure: WARNING: but you will have to use gnuplot or you won't be able
configure: WARNING: to use any of Octave's plotting commands
configure: WARNING:
configure:

NOTE: libraries may be skipped if a library is not found OR
if the library on your system is missing required features.

Per rimediare a questi avvisi ho dovuto installare un po' di pacchetti (come al solito, questi possono essere installati da Synaptic o da terminale, come preferite).
· Per bison è necessario il pacchetto bison.
· Per arpack ho installato i pacchetti libarpack2 libarpack2-dev libibverbs1 libopenmpi1 libopenmpi-dev openmpi-common.
· Per GraphicsMagick++ ho installati i pacchetti libbz2-dev libexif-dev libexpat1-dev libfreetype6-dev libgraphicsmagick++1 libgraphicsmagick++1-dev libgraphicsmagick1 libgraphicsmagick1-dev libice-dev libjasper-dev liblcms1-dev libpng12-dev libpthread-stubs0 libpthread-stubs0-dev libsm-dev libtiff4-dev libtiffxx0c2 libwmf-dev libx11-dev libxau-dev libxcb1-dev libxdmcp-dev libxext-dev libxml2-dev x11proto-core-dev x11proto-input-dev x11proto-kb-dev x11proto-xext-dev xtrans-dev.
· Per FLTK ho installato i pacchetti libfltk1.1 libfltk1.1-dev libgl1-mesa-dev mesa-common-dev
· Per qrupdate ho dovuto scaricare dei pacchetti dagli archivi di Karmic, la versione di Ubuntu che deve ancora essere rilasciata. I pacchetti necessari sono stati libqrupdate1 libqrupdate-dev mpi-default-dev. Facendo clic su ciascuno dei nomi dei pacchetti qui indicati potete scegliere l'architettura del vostro sistema (amd64 o i386) e scaricare i pacchetti deb che potrete installare normalmente.

Dopo aver installato tutti i pacchetti ho nuovamente dato il comando

./configure

che però questa volta non mi ha dato alcun avviso, quindi ho proceduto con il

make

Durante il make, però, ho ricevuto un messaggio di errore:

./DLD-FUNCTIONS/fltk_backend.cc: In member function ‘virtual void OpenGL_fltk::draw_overlay()’:
./DLD-FUNCTIONS/fltk_backend.cc:145: error: ‘gluOrtho2D’ was not declared in this scope
make[2]: *** [pic/fltk_backend.o] Errore 1
make[2]: uscita dalla directory «/home/luke/octave-3.2.2/src»
make[1]: *** [src] Errore 2
make[1]: uscita dalla directory «/home/luke/octave-3.2.2»
make: *** [all] Errore 2

La soluzione a questo problema l'ho trovata su questo sito: installare il pacchetto libglu1-mesa-dev. Ho ricominciato daccapo dal ./configure, che però mi ha dato un nuovo avviso (prima gli sarà sfuggito?):

configure: WARNING: "FTGL headers not found. Native renderer will not have on-screen text"
configure: WARNING:
configure: WARNING: I didn't find the necessary libraries to compile native
configure: WARNING: graphics. It isn't necessary to have native graphics
configure: WARNING: but you will have to use gnuplot or you won't be able
configure: WARNING: to use any of Octave's plotting commands
configure: WARNING:
configure:

NOTE: libraries may be skipped if a library is not found OR
if the library on your system is missing required features.

Per risolvere quest'altro problema ho installato i pacchetti libftgl-dev libftgl2. Dopo di ciò ho dato nuovamente i comandi

./configure

(fortunatamente anche questa volta senza avvisi) e poi

make

Dopo un po' di tempo (credo che a me abbia impiegato circa 2 ore, ma la compilazione potrebbe richiedere anche più tempo (o di meno se siete fortunati)), il processo è terminato ed è comparso il messaggio

Octave successfully built. Now choose from the following:

./run-octave - to run in place to test before installing
make check - to run the tests
make install - to install (PREFIX=/usr/local)

make[1]: uscita dalla directory «/home/luke/octave-3.2.2»

a segnalare (come si può leggere), la fine della compilazione di GNU Octave. A questo punto si può scegliere una delle operazioni suggerite. Per installare il programma si dovrebbe dare, come consigliato, il comando

sudo make install

(il sudo è necessario poiché verranno eseguite delle operazioni in cartelle protetta in scrittura), io però ho preferito creare un pacchetto .deb, in modo da non dover in seguito ricompilare tutto il programma. Per fare ciò, il metodo più semplice (non il migliore, ma per chi non ha bisogno di distribuire i pacchetti questo dovrebbe essere più che sufficiente) è usare checkinstall. Per creare il pacchetto, senza installarlo, bisogna dare il comando

sudo checkinstall --install=no

L'installazione potrà poi essere fatta successivamente, come per tutti i pacchetti deb.

Per compilare l'interfaccia grafica QtOctave 0.8.2 potete leggere qui.

Aggiornamento del 18/08/2009: oggi ho visto che nei repository della prossima versione di Ubuntu (Karmic Koala che uscirà a ottobre) è presente il pacchetto octave-3.2 (~~però alla versione 3.2.0, non la 3.2.2~~ la versione adesso è proprio la 3.2.2), quindi chi non ha fretta di installare subito la 3.2 potrebbe aspettare per l'installazione il rilascio di Ubuntu 9.10 per poterlo installare comodamente dal gestore pacchetti.

Scoprire il tipo di un file

2009-06-12T15:32:00.010+02:00

Per conoscere il tipo di un file si può utilizzare l'utilissimo comando da terminale file. La sintassi per il suo utilizzo basilare è estremamente semplice:

file /percorso/del/file

ovviamente sostituendo a /percorso/del/file il percorso assoluto o relativo (vedi qui per maggiori informazioni) del file di cui si vuole conoscere il tipo. Per esempio, per conoscere il tipo di un file chiamato pippo e posizionato nella Scrivania, nel terminale dobbiamo dare il comando

file ~/Scrivania/pippo

Ricordo che la tilde ~ è l'abbreviazione della cartella home dell'utente che usa il sistema.

Questo programma risulta particolarmente utile quando si vuole individuare la reale "natura" di un file, perché il tipo di un file non si può identificare con la sola estensione. file opera guardando il contenuto del file. Certo può capitare qualche caso in cui anche file sbaglia, ma ciò che determina la "natura" di un file è il suo contenuto, non certo l'estensione che può essere cambiata a piacimento. Per conoscere le opzioni che si possono utilizzare con file potete consultare il manuale con il comando

man file

Chi non ama particolarmente il terminale, o comunque preferisce utilizzare anche delle interfacce grafiche, può usare questo semplice script per Nautilus che ho realizzato:

#!/bin/bash

titolo="Tipo file" # titolo dei popup che verranno visualizzati

if [ $# -gt 0 ]; then # se viene selezionato più di un file
    file -- "$@" | zenity --text-info --title="$titolo" --filename=/dev/stdin # visualizza un popup che mostra il tipo di ciascun file o cartella selezionato
else # altrimenti
    zenity --error --title="$titolo" --text="Devi selezionare almeno un file" # visualizza un popup di errore
fi

Per utilizzare lo script è necessario installare il pacchetto zenity.

Aprite un file vuoto con un editor di testo (come gedit), copiate lo script nell'editor e salvatelo nella cartella ~/.gnome2/nautilus-scripts chiamandolo, per esempio, Tipo file. Rendete quindi eseguibile lo script facendo clic con il taso destro sul file (per accedere alla cartella ~/.gnome2 dovete visualizzare i file nascosti premendo [ CTRL ] + [ H ]), scegliete Proprietà e quindi, nella scheda Permessi, mettete la spunta a Consentire l'esecuzione del file come programma. In questo modo, facendo clic con il tasto destro su un file di cui volete conoscere il tipo, vi basterà fare clic su Script → Tipo file (o il nome che avete dato allo script).

Spostamento celle verso il basso con Incolla speciale in Calc

2009-06-10T16:21:00.007+02:00

In Calc (il foglio elettronico della suite OpenOffice.org) avevo necessità di
· tagliare delle celle
· incollarle in un'altra posizione spostando verso il basso le celle selezionate che contengono altri dati
Questa operazione si potrebbe fare con la funzione Incolla speciale. In pratica basta selezionare le celle da tagliare, fare clic con il tasto destro e scegliere Taglia, quindi selezionare la posizione in cui incollare le celle e, facendo clic con il tasto destro, scegliere Incolla speciale. In questo modo apparirà una finestra in basso a destra della quale si può scegliere di spostare in basso le celle selezionate. Il problema è che l'opzione Verso il basso non era selezionabile. Cercando su Google ho trovato un modo per aggirare il problema.

Bisogna incollare ugualmente, selezionando l'opzione Non spostare, anche se non è quello che vogliamo fare. Quindi nel popup che apparirà che chiederà conferma della sovrascrittura, fate clic su Sì.
In questo modo le celle saranno state, ovviamente, sovrascritte. A questo punto, annullate l'operazione (premendo i tasti [ CTRL ] + [ Z ] oppure da Modifica → Annulla Inserisci) e, facendo clic con il tasto destro sulle celle da spostare, selezionate nuovamente Incolla speciale.
Magicamente, adesso sarà possibile scegliere l'opzione di spostamento verso il basso.
Il messaggio della mailing list dove ho trovato questo workaround risale al 2004, il problema nel frattempo non sembra essere stato risolto (se ho visto bene, comunque, è già stato segnalato agli sviluppatori). Inoltre, mi è sembrato che il difetto si verifichi solamente quando si tagliano delle celle, non quando vengono solamente copiate.

Catturare screenshot

2009-06-05T19:33:00.008+02:00

Se utilizzate Ubuntu nella versione con GNOME come ambiente desktop probabilmente avrete preinstallato il programma gnome-screenshot per catturare le schermate del monitor (in inglese si chiamano screenshot). Se non c'è, per ottenerlo è sufficiente installare il pacchetto omonimo da Synaptic oppure da terminale con il comando

sudo apt-get install gnome-screenshot

Per catturare uno screenshot di tutto il monitor basta premere il tasto [ STAMP ], invece se si vuole catturare solo la schermata della finestra attiva bisogna premere insieme i tasti [ ALT ] + [ STAMP ]. Per utilizzare altre impostazioni (come l'inclusione del puntatore o del bordo di una finestra, oppure il ritardo con cui catturare una schermata) bisogna avviare il programma da Applicazioni → Accessori → Cattura schermata.

Esiste inoltre un altro programma che offre numerose opzioni in più: Shutter (precedentemente conosciuto come Gscrot). Shutter può essere installato aggiungendo un repository (qui sono presenti le istruzioni in inglese per farlo) oppure direttamente dal pacchetto che si può scaricare da questa pagina nella sezione Ubuntu packages (è necessario scaricare tutti i pacchetti indicati per la propria versione del sistema). Shutter potrebbe richiedere l'installazione (che avverrà in automatico) di numerose dipendenze (a me per esempio ha dovuto installare 14 pacchetti mancanti). Una volta installato, Shutter può essere avviato da Applicazioni → Accessori → Shutter - Screenshot Tool. Il programma permette di scegliere il formato in cui salvare l'immagine, di quale finestra cattura la schermata (la rende attiva automaticamente), di quale desktop virtuale catturare un'intera schermata, inoltre offre la possibilità di selezionare un'area rettangolare dello schermo da salvare e modificare lo screenshot appena catturato con il programma di editing grafico preferito. Qui potete trovare una breve guida in italiano per Shutter.

Utilizzando anche Ubuntu con LXDE come ambiente desktop, sono spesso alla ricerca di programmi quanto più leggeri ed essenziali possibile. Per catturare le schermate del desktop è possibile utilizzare da terminale il semplice programma import. Può essere installato da Synaptic, oppure da terminale con il comando

sudo apt-get install import

Per utilizzarlo basta dare il comando

import nomefile

sostituendo a nomefile il nome che si desidera dare allo screenshot. Dopo aver dato il comando si dovrà selezionare l'area del desktop da catturare. L'immagine verrà salvata nella cartella in cui è posizionato il terminale (usare il comando pwd per sapere qual è). È possibile usare qualche altra opzione, consultate il manuale con il comando

man import

per maggiori informazioni.

Un altro programma da utilizzare da terminale per catturare le schermate è scrot. Come al solito, può essere installato da Synaptic, oppure da terminale con il con il comando

sudo apt-get install scrot

Per catturare immediatamente una schermata dell'intero schermo è sufficiente dare il comando

scrot

Con l'opzione -s è possibile selezionare un'area rettangolare dello schermo da salvare (facendo semplicemente clic in una finestra verrà salvata quella finestra); l'opzione -d NUM permette di impostare un ritardo di NUM secondi prima di catturare lo screenshot; l'opzione -c unitamente a -d visualizza un conto alla rovescia prima della cattura della schermata (ricordo che le opzioni possono anche essere scritte tutte insieme, l'importante è che dopo l'opzione -d ci sia il numero di secondi di ritardo). Altre opzioni di scrot possono essere ottenute leggendo il manuale con il comando

man scrot

File e cartelle nascosti nella home

2009-06-05T19:31:00.012+02:00

In genere per ogni utente di un sistema GNU/Linux è presente una cartella home, cioè una cartella sotto /home che ha lo stesso nome dell'utente. Per esempio, se un utente del sistema si chiama pippo, esisterà una cartella il cui percorso è /home/pippo. Spesso, per quanto riguarda la bash, questa cartella viene indicata con la tilde ~ oppure con la variabile $HOME, che stanno entrambe a indicare proprio il percorso della cartella. Queste abbreviazioni risultano molto comode perché indicano sempre il percorso della cartella home dell'utente che sta utilizzando il sistema, indipendentemente dal nome dell'utente stesso.

Generalmente, all'interno della home di ciascun utente si trovano numerosi file e cartelle, ma molti di questi sono nascosti. Un file (o cartella) nascosto in un sistema di tipo Unix ha semplicemente un punto prima del proprio nome: in questo modo, navigando nella cartella il file (o cartella) nascosto non viene visualizzato in maniera predefinita. Proprio perché i nomi dei file nascosti iniziano con un punto in inglese vengono detti dot files (che significa file punto). In Nautilus, il file manager predefinito di GNOME, per visualizzare gli eventuali file nascosti presenti in una cartella è sufficiente premere i tasti [ CTRL ] + [ H ] oppure fare clic su Visualizza e quindi selezionare Mostra file nascosti. Se invece state usando il terminale, il comando normalmente ls non è in grado di elencare i file nascosti presenti in una cartella, bisogna usare l'opzione -a, quindi il comando

ls -a directory

elenca tutti i file, compresi quelli nascosti, presenti nella directory specificata.

Molti dei programmi che si utilizzano quotidianamente salvano le configurazioni personalizzate di ciascun utente all'interno delle rispettive home in cartelle nascoste. Visualizzando i file nascosti della vostra home potrete riconoscere le cartelle di alcuni programmi. Se avete necessità di modificare direttamente il file di configurazione di un programma è probabile che il file si trovi nella cartella nascosta associata a quel software.

Quando si disinstalla un programma generalmente l'eventuale cartella presente nella home di quel programma non viene cancellata, per preservare le configurazioni qualora il programma venisse reinstallato successivamente. La cartella può essere cancellata manualmente dopo la rimozione di un programma, ma può anche essere fatto automaticamente: quando si rimuove un pacchetto da Synaptic, invece di selezionare l'opzione Marca per la rimozione bisogna scegliere Marca per la rimozione completa. Allo stesso modo, se si disinstalla un pacchetto da terminale e si vuole cancellare anche la cartella nascosta contenente le configurazioni, invece dell'usuale

sudo apt-get remove nomepacchetto

bisogna dare il comando

sudo apt-get purge nomepacchetto

o, il che è lo stesso

sudo apt-get remove --purge nomepacchetto

In particolare, molto spesso problemi relativi a Firefox sono proprio collegati al profilo in uso, che si trova nel percorso ~/.mozilla/firefox/nomeprofilo (usualmente il nome della cartella comprende una sequenza casuale di lettere e numeri seguita dal nome del profilo). Una soluzione sarebbe quella di cancellare tutta la cartella .mozilla, ma in questo modo si perderebbero tutti i plugin installati, i Segnalibri, le password salvate e la Cronologia. Un metodo più indolore consiste nel rinominare la cartella .mozilla (ma non cancellarla, per conservare Segnalibri & Co.): in questo modo, all'avvio successivo Firefox creerà automaticamente un nuovo profilo (e quindi una nuova cartella .mozilla/firefox). Un metodo alternativo a quest'ultimo consiste nel creare un nuovo profilo: per fare ciò bisogna avviare Firefox da terminale con l'opzione -ProfileManager:

firefox -ProfileManager

Nella finestra che si aprirà, fate clic su Create Profile. Se in questo modo il problema viene risolto, sarà possibile recuperare dalla cartella del profilo precedente (oppure nella cartella che era stata rinominata) i segnalibri (Segnalibri → Importa e salva → Ripristina → Seleziona file. Cercate la cartella bookmarkbackups del profilo precedente e selezionate il file *.json più recente). A questo proposito potrebbe essere utile eseguire dei periodici backup del proprio profilo (per esempio con il plugin FEBE).

BaShare: semplice programma per condividere file

2009-06-05T17:08:00.002+02:00

Chi usa programmi di messaggistica istantanea come Pidgin sa che i trasferimenti di file tramite protocollo MSN sono molto lenti. Questo perché Pidgin non supporta la connessione diretta fra i due interlocutori per l'invio dei file (segnalazione del bug sul sito ufficiale). Per risolvere questo problema (almeno quando si inviano file) si può usare il programma opensource BaShare, realizzato da Guiodic. Per l'utilizzo del programma non è necessario che il programma sia installato su tutti e due i computer che si scambiano i file (ovviamente è necessario almeno per chi invia il file).

Nella pagina dei download potete trovare, oltre al sorgente, i pacchetti già compilati per diverse distribuzioni, compresa Ubuntu.

Chi utilizza un router potrebbe aver bisogno di scaricare Miniupnpc per aprire automaticamente la porta TCP.

Sul forum in italiano di Ubuntu è presente una discussione su questo programma: http://forum.ubuntu-it.org/index.php/topic,261426.0.html

Inserire caratteri Unicode

2009-06-05T16:31:00.007+02:00

Per inserire dei caratteri Unicode si può usare il comodo programma Gucharmap che fornisce una mappa dei caratteri Unicode disponibili mostrando anche una breve descrizione per ciascuno di essi. Il programma, preinstallato su Ubuntu con GNOME come ambiente desktop, se non presente può essere ottenuto installando, da Synaptic o da terminale, il pacchetto gucharmap. Il comando da dare nel terminale per installarlo è

sudo apt-get install gucharmap

Per avviarlo potete andare in Applicazioni → Accessori → Tabella carattere, oppure è possibile invocarlo tramite terminale con il comando

gucharmap

Facendo doppio clic sul carattere da inserire, questo comparirà nella barra "Testo da copiare:" e facendo clic sul pulsante Copia i caratteri lì presenti verranno salvati negli appunti e potrete quindi incollare i caratteri dove vi servono.

Se però avete necessità di inserire spesso alcuni caratteri particolari e non volete ogni volta aprire Gucharmap, conoscendo il codice Unicode potete farlo semplicemente da tastiera. Bisogna premere contemporaneamente i tasti [ CTRL ] + [ SHIFT ] + [ U ], rilasciare i tasti (a questo punto vi comparirà una u sottolineata: non cancellatela!), scrivere il codice esadecimale del carattere e premere [ Invio ]. Per esempio, volendo inserire il carattere selezionato nell'immagine precedente (che rappresenta una tastiera), vediamo in basso a destra della schermata di Gucharmap che il codice esadecimale associato è 2328. Quindi per inserire quel carattere bisogna premere contemporaneamente [ CTRL ] + [ SHIFT ] + [ U ], rilasciare i tasti, scrivere 2328 e quindi premere [ Invio ]. Nell'immagine sulla sinistra c'è un esempio relativo all'inserimento del simbolo dell'integrale triplo il cui codice Unicode è 222D (nell'inserire il codice esadecimale le lettere possono anche essere minuscole, è indifferente).

Alcuni dei caratteri Unicode che si possono aggiungere con la combinazione [ CTRL ] + [ SHIFT ] + [ U ] seguito dal codice Unicode (ma ovviamente non tutti, i caratteri Unicode sono oltre 100.000!) si possono inserire premendo [ ALT GR ] o [ ALT GR ] + [ SHIFT ] più una particolare lettera o numero. I tasti vanno tutti premuti contemporaneamente. Per esempio, per inserire il carattere æ è sufficiente premere insieme [ ALT GR ] + [ A ], mentre per il simbolo ® bisogna premere contemporaneamente [ ALT GR ] + [ SHIFT ] + [ R ]. Il simbolo tilde ~, molto usato, si ottiene premendo [ ALT GR ] + [ ì ]. Inoltre attivando il Caps lock è possibile scrivere le lettere maiuscole accentate. Così, per avere la È (E con accento grave) basta attivare il Caps lock e premere [ è ]. Invece per la É (E con accento acuto) bisogna attivare il Caps lock e premere [ SHIFT ] + [ è ] (infatti la é si ottiene con [ SHIFT ] + [ è ]).

Un'utile immagine (realizzata da Giorgio Polvara che l'ha distribuita con licenza CC-BY-NC-SA) che illustra i caratteri che si possono ottenere con le combinazioni di tasti di [ ALT GR ] si trova(va) all'indirizzo https://dl.getdropbox.com/u/235886/linuxkeyboard.png
Con queste combinazioni è possibile anche inserire facilmente lettere con dei particolari simboli come la dieresi.

Driver per scheda wireless Atheros AR242x su Ubuntu 9.04

2009-04-27T00:32:00.006+02:00

Per installare il driver sui sistemi Ubuntu 8.04 oppure 8.10 consultate questa guida: http://elubuntu.blogspot.com/2009/02/installare-driver-per-scheda-wireless.html

Sul sistema Ubuntu Jaunty Jackalope appena installato, la mia scheda wireless Atheros AR242x era già funzionante, quindi non ho avuto bisogno di installare nulla di nuovo.

Se qualcuno avesse comunque la necessità di installare il driver per questa scheda su Ubuntu 9.04, la procedura dovrebbe essere del tutto analoga a quella per il sistema Ubuntu 8.10 (non ho avuto la necessità di eseguirla e non l'ho testata personalmente, ma leggendo in giro dovrebbe funzionare). Riporto per completezza tutte le operazioni da eseguire.

Per prima cosa vi serve sapere quale scheda wireless avete sul vostro pc. Per fare ciò, nel terminale digitate

lspci

Se avete una scheda wireless come la mia, a un certo punto dovreste trovare una stringa tipo questa:

03:00.0 Ethernet controller: Atheros Communications Inc. AR242x 802.11abg Wireless PCI Express Adapter (rev 01)

Se vi spaventa mettervi a cercare quella stringa in tutto l'output di lspci fate la ricerca in questo modo:

lspci | grep Atheros

Se avete quindi trovato la mia stessa scheda potete seguire queste guide. La guida è valida anche per schede AR5007eg. Se avete già installato altri driver che però non funzionano vi conviene rimuoverli prima di procedere (Sistema → Amministrazione → Driver hardware).

La procedura di installazione del driver è molto semplice, dove però prima attivare, se non l'avete già fatto, i repository Backports: Sistema → Amministrazione → Sorgenti software e nella scheda Aggiornamenti mettete la spunta a Aggiornamenti non supportati (jaunty-backports)

(l'immagine fa riferimento a Ubuntu 8.10)

Quindi installate il pacchetto linux-backports-modules-jaunty con Synaptic, oppure via terminale con questo comando:

sudo apt-get install linux-backports-modules-jaunty

o cliccando qui. Riavviate il computer e il gioco è fatto!
Se dopo il riavvio il driver continua a non funzionare controllate che il driver non sia incluso nella blacklist dei moduli (cioè la lista nera dei moduli del kernel che non devono essere caricati). Per effettuare la ricerca, potete utilizzare Tracker, oppure il terminale con il comando

grep -r "blacklist ath5k" /etc/modprobe.d/

Segnatevi i file che ottenete come risultato, apriteli da terminale con il comando

gksudo gedit nomefile

e commentate (cioè aggiungete il simbolo cancelletto # a inizio riga) le righe che contengono

blacklist ath5k

Se ancora, dopo il riavvio, la scheda wireless non sembra dare segni di vita, provate a blacklistare altri driver per questa scheda wireless (cioè aggiungete i moduli relativi a questi driver nella lista nera e in questo modo non verranno caricati), per evitare che entrino in conflitto con quello appena installato: alla fine del file /etc/modprobe.d/blacklist aggiungete il seguente testo

# driver madwifi atheros
blacklist ath_pci
blacklist ath_hal

Poiché non potete modificare direttamente il file, dovete aprirlo tramite terminale attraverso il comando gksudo (sostitute a gedit il nome del vostro editor preferito se non avete gedit installato; potete anche usare l'editor da terminale nano):

gksudo gedit /etc/modprobe.d/blacklist

Il post è stato modificato l'ultima volta il 21 luglio 2009

Avanzamento di versione su installazione minimale

2009-04-25T19:11:00.010+02:00

Pochi giorni fa volevo eseguire l'avanzamento di versione da Intrepid a Jaunty su un computer su cui ho installato una versione minimale che utilizza come ambiente desktop LXDE. Tutte le guide che avevo trovato suggerivano di aprire update-manager (il gestore degli aggiornamenti presente su GNOME) ed eseguire l'aggiornamento. Io però non avevo intenzione di installare update-manager perché si porta dietro alcuni altri pacchetti, non molti a dir la verità, ma su un sistema minimale vorrei avere lo stretto indispensabile!

Sul forum di Ubuntu ho quindi scoperto che basta installare solo il pacchetto update-manager-core, cioè lo stesso che serve per eseguire l'aggiornamento sui server (e che, per la cronaca, è anche una dipendenza di update-manager). La procedura di installazione avviene tramite interfaccia a linea di comando, non grafica. Se il terminale vi spaventa o ve ne fate una ragione oppure installate update-manager, comunque non c'è niente di difficile nel fare l'aggiornamento con questo metodo.

Il pacchetto update-manager-core può essere ottenuto tramite Synaptic (se è installato), oppure nel terminale con il comando

sudo apt-get install update-manager-core

Per effettuare l'aggiornamento del sistema è sufficiente dare il comando

sudo do-release-upgrade

e seguire le istruzioni a video. Se dovete avanzare a una versione di sviluppo di Ubuntu (quindi una versione Alpha, Beta o Release Candidate) allora è necessario aggiungere l'opzione --devel-release (che può essere abbreviata con -d):

sudo do-release-upgrade -d

come spiegato, per esempio, qui.

[Risolto] Problema con at: «Cannot open lockfile /var/spool/cron/atjobs/.SEQ: No such file or directory»

2009-04-18T00:39:00.006+02:00

Stasera volevo provare il comando at che serve per eseguire comandi a un orario specificato. Per esempio volevo eseguire immediatamente uno script bash che si trova nella Scrivania (ovviamente per fare questo non è necessario at, era giusto per vedere come funziona). Per fare ciò si può dare il comando

echo "~/Scrivania/script.sh" | at now

però il terminale mi ha risposto in questo modo:

warning: commands will be executed using /bin/sh
Cannot open lockfile /var/spool/cron/atjobs/.SEQ: No such file or directory
bash: echo: errore di scrittura: Pipe interrotta

Il primo messaggio non è preoccupato, non mi è piaciuto invece il secondo. Ci dice che il file /var/spool/cron/atjobs/.SEQ non può essere aperto semplicemente perché non esiste. Ho quindi creato un file vuoto con quel nome con il comando

sudo touch /var/spool/cron/atjobs/.SEQ

Dando nuovamente il comando at, però, ho ricevuto questo output:

warning: commands will be executed using /bin/sh
Cannot open lockfile /var/spool/cron/atjobs/.SEQ: Permission denied
bash: echo: errore di scrittura: Pipe interrotta

A questo punto mi è arrivato in soccorso google: ho scoperto che si trattava di un problema di permessi. Quando ho creato il file con il comando sudo touch il proprietario del file è stato impostato a root (come anche il gruppo, queste informazioni posso essere viste con il comando sudo ls -l /var/spool/cron/atjobs/.SEQ). Invece il proprietario e il gruppo del file dovrebbero essere daemon. Per modificare il proprietario e il gruppo del file ho dato il comando

sudo chown daemon:daemon /var/spool/cron/atjobs/.SEQ

e finalmente ho potuto provare il comando

echo "~/Scrivania/script.sh" | at now

dopo cui è comparso

warning: commands will be executed using /bin/sh
job 1 at Sat Apr 18 00:18:00 2009

Il sito che ho consultato per risolvere questo problema è http://www.mail-archive.com/debian-bugs-dist@lists.debian.org/msg78730.html. Faccio notare che l'autore di quel messaggio ha dovuto eseguire un'ulteriore operazione oltre a quelle che ho indicato. Se le istruzioni che ho esposto non sono state sufficienti date un'occhiata lì.

[Risolto] Problema con cupsd: «Child exited with status 1!»

2009-04-17T14:53:00.013+02:00

A ogni avvio del sistema mi compariva il messaggio

cupsd: Child exited with status 1!

(per maggiori informazioni su CUPS potete vedere qui). Ho controllato i log relativi a CUPS con il comando nel terminale

cat /var/log/cups/error_log

(se non amate leggere file sul terminale potete anche aprire il file /var/log/cups/error_log con un editor di testo qualsiasi). Ho potuto ammirare una lunga sfilza di messaggi di errore di questo tipo:

E [17/Apr/2009:14:14:18 +0200] "/etc/cups/ssl/server.crt" is a bad symlink - No such file or directory

Perciò ho controllato cosa avesse il file /etc/cups/ssl/server.crt che non andava. Il comando

sudo file /etc/cups/ssl/server.crt

mi ha restituito questo output:

/etc/cups/ssl/server.crt: broken symbolic link to `/etc/ssl/certs/ssl-cert-snakeoil.pem'

Nella stessa cartella del file server.crt era presente anche un altro file chiamato server.key:

sudo file /etc/cups/ssl/server.key

Risultato:

/etc/cups/ssl/server.key: broken symbolic link to `/etc/ssl/private/ssl-cert-snakeoil.key'

Ho quindi cancellato i due file che erano solo dei link simbolici non funzionanti. Prima, però, ho per sicurezza creato una copia di quei file, non si sa mai:

sudo cp -pr /etc/cups/ssl/ $HOME

e poi ho rimossi i file nella cartella /etc/cups/ssl/ (non la loro copia di backup salvata nella home) con il comando:

sudo rm /etc/cups/ssl/server.crt /etc/cups/ssl/server.key

A questo punto ho riavviato cups con il comando

sudo /etc/init.d/cups restart

e il messaggio

* Restarting Common Unix Printing System: cupsd [ OK ]

mi ha fatto capire che tutto era andato bene e ho potuto cancellare la copia di sicurezza della cartella /etc/cups/ssl/ con il comando

sudo rm -rf $HOME/ssl/

Esiste anche una soluzione (alternativa a quella precedente, non c'è bisogno di seguirle tutte e due) meno violenta per i file server.crt e server.key: semplicemente creare i file mancanti. Si può fare almeno in due modi differenti (sempre attraverso comandi nel terminale):

cd /etc/ssl/certs/
sudo make-ssl-cert generate-default-snakeoil

oppure reinstallando il pacchetto ssl-cert:

sudo apt-get install --reinstall ssl-cert

Anche dopo queste operazioni va dato il comando per riavviare cups per controllare che il problema sia stato effettivamente risolto.

(Fonte: http://crunchbanglinux.org/forums/topic/53/printing-broken/)

Mancato avvio di APT Key Manager

2009-04-12T21:27:00.011+02:00

Se avete installato su Ubuntu Intrepid (ma forse il problema è presente in Jaunty) il pacchetto gui-apt-key per poter autenticare comodamente attraverso un'interfaccia grafica i repository di terze parti (maggiori informazioni qui) avrete notato che avviando il programma da Applicazioni → Strumenti di sistema → APT Key Manager viene mostrato il seguente messaggio di errore:

Impossibile lanciare la voce di menù
Esecuzione del processo figlio "/usr/bin/su-to-root" fallita (Nessun file o directory)

Il problema è dovuto al comando di esecuzione inserito nel file /usr/share/applications/gui-apt-key.desktop (che è il collegamento presente nel menu). Il comando in questione è, ovviamente, su-to-root. Si tratta di uno script bash che si può ottenere installando il pacchetto menu (fonte). L'installazione può essere fatta tramite Synaptic oppure nel terminale con il comando

sudo apt-get install menu

Se volete evitare di installare il pacchetto menu (che comunque pesa solo circa 400 kB) potete risolvere il problema o modificando direttamente il file del collegamento, in particolare la chiave Exec così come spiegato più avanti, oppure per via grafica. Per seguire quest'ultima strada dovete fare clic con il tasto destro sul menu principale (dove c'è scritto Applicazioni | Risorse | Sistema) e poi selezionare Modifica menu. Si può avviare lo stesso programma da terminale con il comando

alacarte

Quindi sulla sinistra selezionate Strumenti di sistema, e sulla destra selezionate APT Key Manager, quindi fate clic sul pulsante Proprietà sulla destra. Nella finestra che vi si aprirà dovete modificare il comando

/usr/bin/su-to-root -X -c /usr/sbin/gak

gksu -u root /usr/sbin/gak

cioè così com'era nella versione 0.3 presente in Ubuntu 8.04.

Questo piccolo bug è stato segnalato su Launchpad (https://bugs.launchpad.net/ubuntu/+source/gui-apt-key/+bug/282185)

Correzione errori nel file system

2009-04-04T19:06:00.009+02:00

Oggi accendendo il computer mi è comparsa questa (molto poco) rassicurante scritta:

*An automatic file system check (fsck) of the root filesystem failed.
A manual fsck must be performed, then the system restarted.
The fsck should be performed in maintenance mode with the
root filesystem mounted in read-only mode.
*The root filesystem is currently mounted in read-only mode.
A maintenance shell will now be started.
After performing system mainteance, press CONTROL-D
to terminate the maintenance shell and restart the system.
Give root password for maintenance
(or type Control-D to continue):

Il problema è che non sapevo che password inserire per continuare: la password del mio utente, infatti, non è la password di root (e comunque provando a inserire quella password mi segnalava login non valido). Anche avviando il computer in recovery mode la situazione era la stessa. Ho quindi avviato il computer con il Live CD (conservatelo sempre, può tornare molto utile in questi casi) per eseguire il controllo del file system manualmente. Ho dovuto però prima individuare quale fosse il file system su cui è installato Ubuntu. per fare ciò ho dato nel terminale il comando

sudo fdisk -l

che mi ha restituito questo output:

Disco /dev/sda: 40.0 GB, 40027029504 byte
255 testine, 63 settori/tracce, 4866 cilindri
Unità = cilindri di 16065 * 512 = 8225280 byte
Identificativo disco: 0x16281627

Dispositivo Boot Start End Blocks Id System
/dev/sda1 * 1 2433 19543041 7 HPFS/NTFS
/dev/sda2 2434 4866 19543072+ 5 Esteso
/dev/sda5 2434 4759 18683563+ 83 Linux
/dev/sda6 4760 4866 859446 82 Linux swap / Solaris

Disco /dev/sdb: 20.4 GB, 20416757760 byte
255 testine, 63 settori/tracce, 2482 cilindri
Unità = cilindri di 16065 * 512 = 8225280 byte
Identificativo disco: 0x29ab86bc

Dispositivo Boot Start End Blocks Id System
/dev/sdb1 1 2482 19936633+ c W95 FAT32 (LBA)

Ubuntu è installato nel dispositivo il cui sistema si chiama Linux. Nel mio caso il dispositivo è /dev/sda5. Quindi ho eseguito il controllo del file system con il comando

sudo fsck /dev/sda5

Dopo alcune correzioni di errori presenti il controllo è terminato e riavviando il pc sono tornato nuovamente in possesso del computer.

Repository per Pidgin

2009-03-31T15:18:00.017+02:00

Torno a parlare del mio client di messaggistica istantanea preferito: Pidgin. Esiste un repository per aggiornare automaticamente questo programma. L'ho usato per qualche tempo, però l'ultima versione presente fino a pochi giorni fa era la 2.5.1, mentre attualmente l'ultima versione stabile è la 2.5.5. Nel frattempo ho aggiornato Pidgin con i pacchetti deb presenti qui. Da più o meno un giorno, invece, è stata aggiunta al repository proprio la 2.5.5 e ho quindi deciso di aggiungerlo al mio elenco, nella speranza che continueranno ad aggiornarlo in seguito, altrimenti tornerò a usare i pacchetti di Getdeb.net (per altro rapidissimi nel distribuirli).

Vi illustro ora come aggiungere il repository di Pidgin.

Per chi usa una versione di Ubuntu dalla 9.10 (Karmic Koala) in poi è sufficiente dare semplicemente il seguente comando nel terminale

sudo add-apt-repository ppa:pidgin-developers/ppa

senza ulteriori complicazioni, e il repository verrà anche autenticato automaticamente

Per le versioni precedenti, aprite Sistema → Amministrazione → Sorgenti software. Nella scheda Software di terze parti fate clic su Aggiungi e scrivete la seguente stringa

deb http://ppa.launchpad.net/pidgin-developers/ubuntu intrepid main

sostituendo a intrepid il nome della vostra versione di Ubuntu. Se non sapete il nome in codice della vostra release date questo comando nel terminale:

lsb_release -c

A me è apparso questo output:

Codename: intrepid

Quindi, nel mio caso intrepid è il nome da mettere nella stringa mostrata di sopra. Le versioni di Ubuntu che si possono mettere nella stringa sono dapper, gutsy, hardy, intrepid e jaunty.
Potete anche aggiungere il repository da terminale seguendo questa guida.

Dopo aver aggiunto il repository dovete aggiungere la chiave di autenticazione per il repository (come spiegato qui): nel terminale digitate questi comandi:

gpg --keyserver keyserver.ubuntu.com --recv-keys 7FB8BEE0A1F196A8
gpg --export --armor 7FB8BEE0A1F196A8 | sudo apt-key add -

Per autenticare il repository potete anche copiare il contenuto di questa pagina in un editor di testo (a partire da -----BEGIN PGP PUBLIC KEY BLOCK-----), salvatelo in un file, aprite Sistema → Amministrazione → Sorgenti software e nella scheda Autenticazione fate clic su Importa file chiave..., quindi selezionate il file che avete appena salvato. Se la chiave verrà aggiunta correttamente potete anche eliminare il file.

Dopo aver in qualche modo aggiunto il repository vi basta un semplice aggiornamento del sistema per ottenere l'ultima versione di Pidgin. Quindi aprite Sistema → Amministrazione → Gestione aggiornamenti. Nella finestra che si aprirà fate clic su Verifica. A questo punto, se non aveste aggiunto la chiave di autenticazione avreste letto questo messaggio di errore:

W: Errore GPG: http://ppa.launchpad.net intrepid Release: Le seguenti firme non sono state verificate perché la chiave pubblica non è disponibile: NO_PUBKEY 7FB8BEE0A1F196A8

Negli aggiornamenti proposti dovrebbe comparirvi Pidgin, quindi potete fare finalmente clic su Installa aggiornamenti. L'aggiornamento della versione di Pidgin può anche essere fatta da terminale con i due seguenti comandi:

sudo apt-get update
sudo apt-get upgrade

Il primo aggiorna l'indice dei pacchetti installabili, il secondo aggiorna i pacchetti installati di cui è presente una versione più recente.

Aggiornamento dell'1 aprile 2009: hanno aggiunto delle istruzioni per aggiungere il repository anche sul sito stesso di Pidgin quindi nutro qualche speranza in più che aggiorneranno la versione presente nel repository.

Nota: il post è stato aggiornato successivamente alla sua pubblicazione per aggiungere le istruzioni relative alle ultime versioni di Ubuntu.

Impostare scorciatoie da tastiera con xbindkeys

2009-03-23T20:30:00.021+01:00

Utilizzando GNOME come ambiente desktop è possibile impostare delle combinazioni da tastiera senza installare alcun programma semplicemente da Sistema → Preferenze → Scorciatoie da tastiera. Oggi però ho voluto provare un metodo "alternativo" per impostare le scorciatoie. xbindkeys può tornare utile se si utilizzano desktop environment diversi da GNOME e che non offrono la possibilità di modificare le scorciatoie (~~per esempio, in questi giorni sto provando LXDE non ho trovato altri modi di impostare scorciatoie personalizzate~~ Come segnalato da un lettore anonimo, in LXDE è possibile impostare le scorciatoie modificando il file ~/.config/openbox/lxde-rc.xml. Maggiori informazioni a questo proposito possono essere trovate qui). Vi illustro le operazioni da fare.

Per prima cosa dovete installare il programma necessario che si chiama xbindkeys. Potete installarlo con Synaptic oppure da terminale con il comando

sudo apt-get install xbindkeys

Se dopo aver installato il pacchetto provate a dare il comando

xbindkeys

leggerete questo messaggio di errore:

Error : /home/nomeutente/.xbindkeysrc not found or reading not allowed.
please, create one with 'xbindkeys --defaults > /home/nomeutente/.xbindkeysrc'.
or, if you want scheme configuration style,
with 'xbindkeys --defaults-guile > /home/nomeutente/.xbindkeysrc.scm'.

(ovviamente al posto di nomeutente comparirà il nome del vostro utente) quindi, come suggerito, digitate il comando

xbindkeys --defaults > ~/.xbindkeysrc

(vi ricordo che la tilde ~ è un'abbreviazione del percorso della vostra cartella home). È stato dunque creato il file .xbindkeysrc nella vostra cartella home. Il suo nome inizia con il punto e questo significa che è un file nascosto. Per vederlo, entrate nella vostra home (Risorse → Cartella home) e, se non visualizzate i file nascosti, premete i tasti [ CTRL ] + [ H ] per far "apparire" il nostro file. Potete quindi aprire .xbindkeysrc per guardarlo.

In ogni riga, tutto ciò che si trova alla destra del cancelletto # è un cosiddetto commento. Ciò che vi interessa sono le righe del tipo

"xterm"
c:41 + m:0x4

in cui la prima indica il comando da eseguire (xterm è un emulatore del terminale) e la seconda corrisponde alla combinazione di tasti da premere per eseguire il comando (in questo caso dovrebbe essere [ CTRL ] + [ F ]).

Ora però noi vogliamo aggiungere una nuova scorciatoia da tastiera per velocizzare le operazioni più comuni. Per esempio, vogliamo creare la scorciatoia [ ALT ] + [ T ] per aprire il terminale di GNOME che si invoca con il comando gnome-terminal (e che è diverso esteticamente dal terminale che si apre con il comando xterm). Nel terminale inserite il comando

xbindkeys -k

oppure

xbindkeys --key

e vi uscirà scritto

Press combination of keys or/and click under the window.
You can use one of the two lines after "NoCommand"
in $HOME/.xbindkeysrc to bind a key.

e quindi premete la combinazione di tasti che vi interessa (nell'esempio sarà [ ALT ] + [ T ]). Dopo che avrete premuto i tasti comparirà la scritta

"(Scheme function)"
m:0x18 + c:28
Alt+Mod2 + t

Ora per completare l'operazione non vi resta che ricopiare nel file .xbindkeysrc, prima della stringa End of xbindkeys configuration, queste tre righe, sostituendo (nel nostro esempio) a "(Scheme function)" la scritta "gnome-terminal". Un consiglio utile è di scrivere un piccolo commento prima del comando, in modo da ricordarsi in seguito qual è la combinazione aggiunta. Quindi, in concreto, dovrete aggiungere le seguenti righe:

# Apre "gnome-terminal" con la combinazione ALT + T
"gnome-terminal"
m:0x18 + c:28
Alt+Mod2 + t

Potete anche aggiungere solo una delle ultime due righe (m:0x18 + c:28 oppure Alt+Mod2 + t).

Se avete intenzione di aggiungere numerose combinazioni di tasti, non c'è bisogno di usare il comando xbindkeys -k ogni volta, potete usare

xbindkeys -mk

oppure

xbindkeys --multikey

e poi premere il tasto [ Q ] quando avete finito.

Le combinazioni di tasti possono anche comprendere i tasti del mouse. Normalmente xbindkeys non fa distinzione se siano attivi NumLock, CapsLock e ScrollLock. Se invece volete impostare questo controllo dovete decommentare (cioè rimuovere il #) prima delle seguenti righe (nel mio file .xbindkeysrc compaiono ai righi 36-38)

#keystate_numlock = enable
#keystate_capslock = enable
#keystate_scrolllock= enable

Ovviamente potete anche decommentare solo quello che vi interessa, non necessariamente tutti e tre.

Una volta che è pronto il vostro file di configurazione per xbindkeys vi resta un'ultima semplice operazione da fare: seguendo queste istruzioni aggiungete ai programmi in esecuzione automatica all'avvio della sessione il comando xbindkeys.

Compilare il pacchetto purple-plugin_pack

2009-03-07T14:40:00.022+01:00

Oggi avevo deciso di compilare il pacchetto purple-plugin_pack che aggiunge circa 50 nuovi plugin al client di messaggistica istantanea Pidgin. Nei repository di Ubuntu si trova già il pacchetto pidgin-plugin-pack, però è alla versione 2.2.0 mentre sul sito ufficiale è presente il sorgente della versione 2.5.1. Se non avete già compilato altri plugin per Pidgin né Pidgin stesso dovete prima installare i pacchetti necessari dando nel terminale il seguente comando:

sudo apt-get install build-essential pidgin-dev

Se non amate il terminale (che comunque sarà necessario in seguito per compilare il pacchetto) potete installare i due pacchetti facendo clic sui nomi, oppure con Synaptic. In realtà, se avete compilato da soli Pidgin non dovreste incontrare i problemi che ho trovato io e questa guida molto probabilmente non vi interesserà.

Dopo di ciò scaricate il sorgente di purple-plugin_pack e scompattatelo (clic con il tasto destro sull'icona dell'archivio → Estrai qui). Ora aprite il terminale, se non l'avete già fatto, e spostatevi con il comando cd nella cartella dove avete scompattate il sorgente. Date il comando

./configure

Se tutto è andato bene, alla fine dell'esecuzione comparirà la scritta

Type make to compile

quindi potete procedere. Se non aveste installato pidgin-dev avreste letto questo messaggio di errore:

No package 'purple' found

Consider adjusting the PKG_CONFIG_PATH environment variable if you
installed software in a non-standard prefix.

Alternatively, you may set the environment variables PURPLE_CFLAGS
and PURPLE_LIBS to avoid the need to call pkg-config.
See the pkg-config man page for more details.

A questo punto date il comando:

make

Qui, però, ho incontrato un problema: mi è comparso il seguente errore (seguito da altri messaggi, ma l'errore è questo):

/usr/bin/ld: cannot find -lpurple
collect2: ld returned 1 exit status

Il problema stava nel file /usr/lib/libpurple.so, infatti il comando

file /usr/lib/libpurple.so

restituiva come output

/usr/lib/libpurple.so: broken symbolic link to `libpurple.so.0.5.2'

ciò vuol dire che il file in questione è un collegamento simbolico ma il file a cui dovrebbe puntare non esiste. Ho quindi cercato file che si chiamassero libpurple.so.0 con il comando

locate libpurple.so.0.

Se non non riceve risultati potreste dover aggiornare il database con il comando

sudo updatedb

Il mio output del comando locate libpurple.so.0. è stato

/usr/lib/libpurple.so.0.5.5

Quindi il file trovato è stato /usr/lib/libpurple.so.0.5.5. Ho perciò creato il collegamento simbolico mancante con il comando

sudo ln -s /usr/lib/libpurple.so.0.5.5 /usr/lib/libpurple.so

Dopo di ciò ho potuto riprendere la compilazione del pacchetto con il comando

make

e poi

sudo make install

Se avete concluso con successo la compilazione, aprendo Pidgin troverete tutti i nuovi plugin pronti all'uso.

Dopo aver compilato il pacchetto potete anche creare un file .deb per poter più facilmente installare successivamente i plugin. Io ho utilizzato con successo checkinstall (dopo aver installando il pacchetto checkinstall (chi l'avrebbe mai detto, no?)). Il comando da dare per creare il pacchetto è:

checkinstall --install=no

Analoghi problemi (con analoghe soluzioni) potrebbero essere incontrati compilando il plugin Guifications.

Creare nuovi modelli di file per Nautilus

2009-03-06T22:42:00.013+01:00

In Nautilus (il file manager predefinito di GNOME) avrete notato che c'è la possibilità di creare un nuovo documento vuoto (clic con il tasto destro in una cartella → Crea documento → File vuoto). Avrete anche notato che sopra l'opzione File vuoto c'è scritto Nessun modello installato (se non leggete questa scritta probabilmente questa guida non vi servirà).
Magari a questo punto vi sarà anche venuta la curiosità di come si facciano a creare dei modelli (chiamati in inglese Templates) personalizzati. È semplicissimo. Aprite Nautilus (per esempio da Risorse → Cartella home) e poi aprite Vai → Modelli. Questo vi porterà nella cartella ~/Modelli (ricordo che la tilde ~ indica il percorso della vostra cartella home, per esempio /home/nomeutente) oppure la creerà se non esiste. Volendo, potete anche creare la cartella manualmente. A questo punto non dovete far altro che salvare in questa cartella i modelli che preferite. Dopo che avrete salvato i modelli (ovviamente dategli dei nomi chiari) il risultato sarà simile a questo:
Se dopo aver creato la cartella e salvato dentro i vostri modelli questi non dovessero comparire nel menu mostrato nell'immagine, provate a chiudere tutte le finestre di Nautilus e poi riaprire. Se dopo di ciò non dovesse ancora funzionare, aprite il file ~/.config/user-dirs.dirs e controllate che ci sia la riga

XDG_TEMPLATES_DIR="$HOME/Modelli"

Se per qualche motivo non ci dovesse essere, oppure è diversa, modificatela come scritto sopra. Potete anche modificare il percorso inserendone uno a vostro piacimento ($HOME è un altro modo per indicare la cartella home dell'utente corrente).

Qui potete trovare una raccolta di modelli, ovviamente da salvare nella cartella ~/Modelli (o in quella che avete impostato). Se i nomi dei file in inglesi non vi piacciono rinominate semplicemente i modelli salvati nella cartella.

Mini guida all'utilizzo di StartUp Manager

2009-02-23T15:40:00.009+01:00

Nota: questo post fa particolare riferimento alal versione 0.97 di GNU GRUB. A partire da Ubuntu Karmic Koala 9.10 è utilizzato come bootload una versione più recente di questo software (Grub 2), che ha una sintassi nei file molto differente da quella descritta in questo post. Startup Manager è comunque utilizzabile con Grub 2.

Chi ha installato sistemi in dual boot ha familiarità con il boot loader GNU GRUB. È il programma che permette di scegliere quale sistema avviare al momento dell'accensione del computer. GRUB è comunque presente in moltissimi sistemi GNU/Linux (compreso Ubuntu). Volendo cambiare le impostazioni di GNU GRUB (versione 0.97) si dovrebbe modificare il file /boot/grub/menu.lst (che in altre distro come Fedora e Gentoo Linux si chiama /boot/grub/grub.conf (fonte)). Modificare manualmente il file non è propriamente semplice per gli utenti novizi, ma fortunatamente arriva in nostro soccorso il programma con interfaccia grafica StartUp Manager.

L'installazione di StartUp Manager può essere fatta con Synaptic o tramite terminale, installando il pacchetto startupmanager (fate clic sul nome per installarlo automaticamente). Il comando da dare tramite terminale per installare il pacchetto è

sudo apt-get install startupmanager

Una volta installato, il programma può essere avviato da Sistema → Amministrazione → StartUp-Manager oppure con il terminale con il comando

sudo startupmanager

Vediamo ora come funziona.

Scheda Opzioni di boot:

Timeout: il timeout è il tempo (espresso in secondi) dopo il quale si avvia il sistema operativo predefinito, se non viene premuto nessun tasto. Regolatelo in modo che non sia troppo breve (per esempio 1-2 secondi) altrimenti potreste non fare neanche in tempo a scegliere un sistema diverso da quello predefinito (equivale a modificare l'opzione timeout nel file di configurazione di GRUB)

Sistema operativo predefinito: è l'opzione che all'apertura di GRUB è già selezionata. Come detto prima, se dopo alcuni secondi (regolati nel timeout) non viene premuto nessun tasto viene avviato quel sistema operativo (equivale a modificare l'opzione Default nel file di configurazione di GRUB). Potete scegliere anche l'opzione Ultimo utilizzo, cioè l'ultimo sistema avviato nella sessione precedente. NOTA: potreste voler modificare questa opzione in caso di aggiornamento del kernel. Infatti quando aggiornate il kernel senza rimuovere quelli precedenti, al menu di boot vengono aggiunte due voci (il nuovo kernel e il relativo recovery mode) e viene pertanto modificato il sistema predefinito.
Schermo: potete modificare le dimensioni e la profondità del colore (se non avete intenzione di personalizzare l'aspetto potete lasciare queste impostazioni così come sono).
Miscellanea: Se non ci sono altri sistemi operativi installati il menu di GRUB è nascosto (vi si può comunque accedere quando si legge la scritta Press ESC to enter the menu...). Invece, selezionando l'opzione Mostra il menu del bootloader all'avvio verrà mostrato il menu (equivale a commentare l'opzione hiddenmenu nel file di configurazione di GRUB).
Selezionando l'opzione Mostra il boot splash viene visualizzato uno splash screen (equivale ad aggiungere splash alle opzioni di caricamento di un kernel, nel file di configurazione di GRUB).
L'opzione Mostra testo visualizza durante il bootstrap le operazioni che vengono eseguite (equivale a togliere quiet dalle opzioni di caricamento di un kernel, nel file di configurazione di GRUB).

Scheda Aspetto:
Utili informazioni per configurare l'aspetto di GRUB possono essere trovate qui: http://wiki.ubuntu-it.org/AmministrazioneSistema/Grub/StartUpManager#head-779de9f970066f907047375144554150ab5fb236.
Altri splash per GRUB si possono ottenere installando con Synaptic o il terminale il pacchetto grub-splashimages (per Kubuntu: kubuntu-grub-splashimage). Da terminale il comando da dare è

sudo apt-get install grub-splashimages

Scheda Sicurezza:

Opzioni di protezione: Password di protezione bootloader equivale a decommentare la stringa #password topsecret nel file di configurazione di GRUB (quando viene inserita la password la stringa diventerà del tipo password --md5 password)
Password per proteggere la modalità di ripristino equivale a cambiare la stringa # lockalternative=false in # lockalternative=true nel file di configurazione di GRUB
Password per proteggere le vecchie impostazioni di boot equivale a cambiare la stringa # lockold=false in # lockold=true nel file di configurazione di GRUB

Scheda Avanzate:

Numero di Kernel: con l'opzione Limita il numero di kernel nel menu di boot si può fare in modo che all'avvio non vengano elencati tutti i kernel elencati ma solo il numero che viene impostato. Comoda opzione per evitare che il menu di boot diventi troppo lungo quando ci siano numerosi kernel installati.
Miscellanea: Crea un opzione di boot per il memtest86+ aggiunge la possibilità di effettuare un test sulla memoria RAM al menu di boot (equivale a cambiare la stringa # memtest86=false in # memtest86=true nel file di configurazione di GRUB).
Crea un opzione di boot per la modalità di recupero aggiunge la possibilità di effettuare l'accesso in recovery mode (equivale a cambiare la stringa # alternative=false in # alternative=true nel file di configurazione di GRUB).
Aggiorna automaticamente le opzioni predefinite di boot equivale a modificare la stringa # updatedefaultentry=false in # updatedefaultentry=true nel file di configurazione di GRUB
Crea un floppy ripristino permette di creare un floppy da utilizzare per il successivo ripristino del menu di GRUB, in caso di necessità
StartUp Manager crea una copia di backup del file /boot/grub/menu.ls e si può riportare il file alle condizioni originali con l'opzione Ripristina le impostazioni originali

Chi desiderasse provare a modificare a proprio rischio e pericolo (un'errata configurazione può causare l'impossibilità di avviare il sistema operativo) il file di GRUB può leggere la guida http://wiki.ubuntu-it.org/AmministrazioneSistema/Grub. Nella guida ho anche voluto evidenziare come si può ottenere lo stesso effetto (quando sono stato in grado di determinarlo) modificando il file /boot/grub/menu.ls.

Un'altra guida per StartUp Manager si trova all'indirizzo http://wiki.ubuntu-it.org/AmministrazioneSistema/Grub/StartUpManager.

Per ripristinare GRUB in caso di necessità (se per esempio dopo l'installazione di Ubuntu viene installato Windows, GRUB viene sovrascritto) potete leggere questa guida: http://wiki.ubuntu-it.org/AmministrazioneSistema/Grub/Ripristino.

Esistono anche altri programmi per modificare il file di GRUB come QGRUBEditor.

Autoremove vuole rimuovere troppi pacchetti

2009-02-20T18:04:00.014+01:00

Un comodo strumento da utilizzare per la pulizia del sistema è la rimozione automatica dei pacchetti non più necessari (cioè pacchetti installati perché dipendenze di altri pacchetti che sono stati rimossi nel frattempo). Per fare ciò bisogna digitare nel terminale il seguente comando:

sudo apt-get autoremove

Oppure su Synaptic si può cliccare, in basso a sinistra, su Stato e poi in alto a sinistra scegliere Installato (auto removibile). Sulla destra verranno elencati i pacchetti non più necessari e che possono quindi essere rimossi.

(fonte immagine: http://wiki.ubuntu-it.org/AmministrazioneSistema/Synaptic)

Questo strumento, però, va utilizzato con buon senso e molta attenzione (a ogni modo la rimozione dei pacchetti non è automatica ma viene prima chiesto il consenso per procedere). A volte, purtroppo, può capitare che venga suggerita la rimozione di pacchetti in realtà necessari. Mi è capitato che disinstallando OpenOffice.org 2.4.1 mi venissero segnati come inutili alcuni pacchetti utili, fra cui, per esempio, gimp-help-it (la documentazione in italiano di Gimp). Fortunatamente si può, però, evitare che utilizzando apt-get autoremove venga suggerita la rimozione di questi pacchetti che in realtà sono utili. Basta aprire Synaptic (Sistema → Amministrazione → Gestore pacchetti Synaptic), selezionare il pacchetto desiderato, quindi aprire il menu Pacchetto e rimuovere la spunta a Installato automaticamente (semplicemente cliccandoci sopra).

Ovviamente, se volessimo annullare questo cambiamento è sufficiente cliccare nuovamente su Installato automaticamente, dopo aver selezionato il pacchetto.

Gli stessi risultati si possono ottenere via terminale. Per segnare un pacchetto come installato manualmente dobbiamo inserire il seguente comando:

sudo aptitude unmarkauto nomepacchetto

ovviamente sostituendo a nomepacchetto il nome del pacchetto che si desidera non segnare più come installato automaticamente. Quindi, nel caso volessimo che gimp-help-it non sia più segnato come installato automaticamente, attraverso il terminale il comando da dare è:

sudo aptitude unmarkauto gimp-help-it

Per ripristinare lo stato di "installato automaticamente" di un pacchetto il comando da dare è:

sudo aptitude markauto nomepacchetto

Filmati Flash con Firefox

2009-02-19T16:44:00.008+01:00

Per visualizzare per bene con Firefox i filmati Flash presenti in giro per la rete dovete installare il pacchetto flashplugin-nonfree se usate Ubuntu 8.10 o 9.04, oppure adobe-flashplugin se usate Ubuntu 8.04 e disinstallare (se presenti) i pacchetti swfdec-mozilla e mozilla-plugin-gnash. Tutto ciò può essere fatto comodamente da Synaptic, ma per chi preferisce il terminale può dare:

sudo apt-get remove swfdec-mozilla mozilla-plugin-gnash

per disinstallare i pacchetti non necessari. Invece per installare ciò che vi serve, su Ubuntu 8.10 oppure 9.04 dovete usare il comando:

sudo apt-get install flashplugin-nonfree

su Ubuntu 8.04:

sudo apt-get install adobe-flashplugin

Chi è pigro, invece, può cliccare sul nome dei pacchetti per installarli.
I plug-in che abbiamo disinstallato sono quelli open-source ma purtroppo non permettono una perfetta visualizzazione dei contenuti flash. I risultati sono molto migliori installando il plug-in proprietario. Per esempio, un problema a utilizzare i pacchetti swfdec-mozilla è che aprendo una pagina contenente un filmato flash, al posto del video si vedrà un grande simbolo grigio di play che deve essere premuto per visualizzare il filmato.

(fonte: http://wiki.ubuntu-it.org/InternetRete/Flash)

Installazione dei driver per la scheda video con Envy

2009-02-15T18:00:00.011+01:00

Attenzione: come riportato sul sito, Envy non è più supportato a partire dalla versione 10.04 di Ubuntu, per installare i driver delle schede video è consigliato usare Jockey al suo posto.

Per poter utilizzare tutti gli effetti grafici messi a disposizione su Ubuntu è necessario, ovviamente, installare i driver giusti della propria scheda video.

In generale, un modo per installare i driver è quello di aprire Sistema → Amministrazione → Driver hardware e installare il driver che vi viene consigliato (se c'è).

Un'altra via è il programma Envy. Envy offre un grosso aiuto per installare i driver delle schede video Nvidia e Ati ed è dotato sia di interfaccia a caratteri sia grafica. Personalmente ho utilizzato quella a caratteri, anche perché quella grafica richiedeva l'installazione di numerosi pacchetti aggiuntivi, probabilmente inutili una volta installato il driver. Per installare Envy bisogna installare il pacchetto envyng-core, o via Synaptic o con il terminale, con il comando

sudo apt-get install envyng-core

o fare clic qui.
Se proprio volete installare anche l'interfaccia grafica dovete installare envyng-qt e tutte le dipendenze annesse. Per avviare Envy da terminale con interfaccia a caratteri:

envyng -t

e dopo di ciò vi basterà seguire le istruzioni.

«E se non so che scheda video ho?» Con il comando

lspci | grep VGA

troverete il nome della vostra scheda video. La mia ha la seguente descrizione:

05:00.0 VGA compatible controller: nVidia Corporation GeForce 8400M GS (rev a1)

Per chi fosse interessato, il driver che ho installato è il 173.14.12 e ho tutti gli effetti grafici perfettamente funzionanti.

Per maggiori informazioni su Envy potete visitare il sito http://www.albertomilone.com/nvidia_scripts1.html

Controllare quanto si è scaricato da Internet

2009-02-15T17:58:00.007+01:00

Utilizzando un piano telefonico che prevede il pagamento in base alla quantità di dati scaricati risulta molto comodo poter monitorare il traffico quotidiano, settimanale, mensile. In questo caso arriva in vostro aiuto il programma vnstat. Ha interfaccia a linea di comando (cioè si utilizza attraverso il terminale), ma il suo utilizzo è molto semplice. Può essere facilmente installato da Synaptic (si trova nel componente universe dei repository), o con il comando

sudo apt-get install vnstat

oppure cliccando qui. Subito dopo l'installazione sarà necessario creare il database. Infatti, provando a lanciare il programma da terminale riceviamo il seguente errore:

No database found, nothing to do. Use --help for help.

A new database can be created with the following command:
vnstat -u -i eth0

Replace 'eth0' with the interface that should be monitored.

The following interfaces are currently available:
lo eth0

Io utilizzo una rete ethernet, quindi ho dovuto il comando per creare il database è proprio quello indicato. Attenzione però! Il database verrà creato sotto /var/lib/vnstat e voi non avete accesso diretto a quella cartella, dovrete quindi utilizzare il solito comando sudo. Senza di esso leggereste questo messaggio di errore:

Error: Unable to read database "/var/lib/vnstat/eth0".
Error: Unable to write database "/var/lib/vnstat/eth0".

Abbiamo quindi capito che il comando da dare è:

sudo vnstat -u -i eth0

sostituendo, eventualmente, a eth0 l'interfaccia di rete che utilizzate (per scoprire qual è con Network Manager: clic con il tasto destro sull'icona dei monitor → Informazioni connessione e leggete cosa c'è scritto a Interfaccia. L'elenco delle interfacce disponibili può anche essere consultato con il comando ifconfig).

Sul sito di vnstat, http://humdi.net/vnstat/, potete vedere alcuni "screenshot" del programma.