ott
24

AUCTeX: parsing automatico di tutti i pacchetti LaTeX presenti nel sistema

 

Fra le miriadi di funzioni disponibili in AUCTeX, il pacchetto per Emacs per la composizione di documenti *TeX, c è la possibilità di effettuare il parsing automatico di tutti i pacchetti *TeX presenti nel proprio sistema. La comodità di questa funzione è che Emacs in questo modo conoscerà tutti i comandi (e relativa sintassi: numero di opzioni e argomenti) definiti da tutti i pacchetti analizzati. Quando in un sorgente LaTeX caricherete uno dei pacchetti analizzati, in Emacs sarà possibile utilizzare C-c RET o C-c C-m per inserire i comandi conosciuti (e Emacs vi proporrà anche il giusto numero di opzioni e argomenti obbligatori). Purtroppo non sono tutte rose e fiori, all inizio ho detto un imprecisione: non va bene per tutti i pacchetti, infatti l analisi sintattica dà il meglio di sé con pacchetti non troppo complicati e AUCTeX attualmente non è in grado di comprendere la sintassi di LaTeX3. Quindi per questi pacchetti i risultati non saranno quelli attesi.

Si può fare questo (mezzo) prodigio utilizzando i comandi TeX-auto-generate e TeX-auto-generate-global. La prima funzione, eseguibile dentro Emacs con M-x TeX-auto-generate, richiede l inserimento del file di stile di classe *TeX da analizzare (oppure della cartella in cui cercare ricorsivamente questi file) e della cartella in cui andare a salvare le informazioni (per default il valore della variabile TeX-auto-private che per default dovrebbe valere "~/.emacs.d/auctex/auto").

Il secondo comando, eseguibile dentro Emacs con M-x TeX-auto-generate-global, analizza tutti i file presenti nelle cartelle elencate nella variabile TeX-macro-global e salva le informazioni nella cartella indicata dalla variabile TeX-auto-global (che dovrebbe valere "/var/lib/auctex/emacsXX", con al posto di XX il numero di versione di Emacs). La variabile TeX-macro-global deve contenere il percorso delle cartelle in cui sono presenti, ricorsivamente, i pacchetti *TeX in uso. Quindi una buona idea è quella di inserire nell elenco, per esempio, la cartella /usr/local/texlive/2012/texmf-dist/tex/ o qualunque sia la cartella contenente i file di stile e di classe. Poiché generalmente la cartella in cui Emacs scriverà le informazioni (/var/lib/auctex/emacsXX in maniera predefinita) è una cartella di sistema, non accessibile in scrittura all utente corrente se non è amministratore, è necessario eseguire questa funzione dentro una sessione di Emacs avviato con i permessi di amministratore. In alternativa si può semplicemente eseguire da terminale il seguente comando:

sudo emacs -batch -f TeX-auto-generate-global

che esegue il comando, con i permessi di amministratore, senza aprire una nuova finestra di Emacs. Può essere utile eseguire questo comando ogni volta che si aggiorna AUCTeX o che vengono aggiornati i pacchetti della propria distribuzione *TeX. Si noti, però, che l operazione può richiedere diversi minuti e un elevato consumo della CPU (Emacs deve leggere, interpretare e scrivere alcune migliaia di file), anche se le esecuzioni della funzione successive alla prima (se sono cambiati solo pochi pacchetti e non è stato aggiornato AUCTeX) richiederanno un tempo sensibilmente minore.

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

ott
06

[Risolto] cannot connect to X server :0

 

A differenza di GNOME, in KDE non è possibile avviare applicazioni grafiche direttamente con sudo. Infatti, se in KDE si prova a eseguire con sudo un applicazione grafica da utilizzare con i permessi di amministratore, si potrà ricevere un messaggio di errore di questo tipo

$ sudo kateQDBusConnection: session D-Bus connection created before QCoreApplication. Application may misbehave.No protocol specifiedkate: cannot connect to X server :0

La soluzione è semplice: basta utilizzare kdesudo (assicurarsi di aver installato il pacchetto omonimo) al posto del solo sudo:

$ kdesudo kate

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

lug
26

Scaricare facilmente video con tecnologia Silverlight (Smooth Streaming) in Linux

 

È già da un po’ di tempo che se ne parla, i siti di alcune delle maggiori televisioni (Rai e Mediaset) utilizzano la tecnologia Silverlight per pubblicare molti video che si possono (ri)vedere online. Si tratta di un sacco di programmi, fiction, telegiornali, eccetera forniti direttamente dalle suddette reti televisive, quindi si tratta di uno streaming perfettamente legale.

Il problema è che Silverlight è una tecnologia proprietaria di Microsoft che non è molto ben supportata da Linux. È vero, esiste il progetto Moonlight (sostanzialmente fermo), il quale però non supporta a pieno la riproduzione dei video di questi portali. Inoltre non è possibile scaricare le puntate offerte con tecnologia Smooth Streaming allo stesso modo in cui si fa solitamente con i siti che pubblicano video in Flash. Perciò tutto questo complica usi perfettamente legittimi (e prevedibili) dei video, come ad esempio poterli guardare in treno senza avere un computer con connessione 3G.

Per Linux esiste un progetto chiamato smooth-dl, realizzato da Antonio Ospite, un prolifico sviluppatore di software libero. Per i dettagli sul progetto e la tecnologia di Smooth Streaming, vi rimando al suo articolo che è scritto molto meglio di quanto potrei fare io.

Smooth-dl è però ancora in uno stato “non perfetto”, nel senso che non supporta tutti i siti che offrono video con questa tecnologia, ma lavora bene con il sito Rai. Esiste un software più completo chiamato ismdownloader, che però è realizzato per Windows. Perciò ho deciso di realizzare uno script che “maschera” il programma sotto Wine, e arricchisce la visualizzazione dello stato del download calcolando la percentuale rimanente e mostrandola a video. Di seguito vi spiegherò come effettuare la prima configurazione e poi usare lo script.

Creare l’ambiente Wine

Per evitare di “far confusione” e mischiare il programma che useremo per il download con altri eventuali software che girano sotto Wine, vi farò creare un “contenitore” personalizzato con una copia a se stante del disco “C:” simulato. Per prima cosa quindi nel terminale create la directory, dichiaratela come il prefisso di Wine che andrete ad utilizzare e poi “forzate” Wine all’uso dell’architettura a 32bit:


mkdir -p $HOME/.smoothwine
export WINEPREFIX=$HOME/.smoothwine
WINEARCH=win32 winecfg

Appena finisce di creare la configurazione e vi apre la finestra di Wine, potete chiuderla e proseguire. A questo punto vi servirà Winetricks, che solitamente (perlomeno su Ubuntu) viene installato assieme a Wine, altrimenti provvedete ad installarlo dal vostro gestore di pacchetti. Winetricks si occuperà di scaricare l’ambiente .Net Framework, che servirà poi ad eseguire il programma per il download vero e proprio dei video:


winetricks dotnet20

Seguite la semplice procedura nella finestra che si aprirà e .Net verrà installato. Ora non vi resta altro da fare che cliccare questo link e salvare l’archivio ZIP, dal quale dovrete estrarre solo il file EXE e copiarlo nella cartella che potete aprire usando questo comando:


xdg-open $WINEPREFIX/drive_c

Questo termina la configurazione di Wine. Giunti a questo punto potete procurarvi una copia dello script smooth.sh col comando seguente, che lo salva nella vostra cartella home:


wget "http://pastebin.com/raw.php?i=b9u2EvgK" -O $HOME/smooth.sh
dos2unix $HOME/smooth.sh
chmod +x $HOME/smooth.sh

Per il secondo comando dovrete avere installato dos2unix, mi spiace per l’inconveniente ma a volte PasteBin “rovina” gli script, e la seconda riga serve ad assicurarsi che tutto funzioni. Ovviamente se volete potete spostarlo dove vi pare, l’importante poi è che lo richiamate correttamente.

Scaricare i video in Smooth Streaming

La parte di configurazione di cui sopra andrà fatta solo la prima volta, in seguito potete limitarvi all’utilizzo dello script come segue. Supponendo che lo script sia nella vostra home e la vostra directory corrente nel terminale sia altresì la medesima cartella, potete semplicemente richiamarlo come segue:


./smooth.sh "http://url/del/manifest" "nome"

Il primo parametro sarà l’URL del cosiddetto file “manifest” relativo al video. Qui viene il problema: ogni pagina web avrà un manifest diverso, e il metodo per ricavarne l’URL varia da sito a sito. Per questo motivo non posso dirvi dettagliatamente come fare a trovarlo in generale, perché la spiegazione sarebbe molto lunga. Per certi siti come quelli di Rai e Mediaset ci sono già delle indicazioni in rete, in ogni caso questo sarà oggetto di un mio prossimo articolo, dedicato appositamente a scovare gli URL dei video online.

Il secondo parametro è il nome (preferibilmente senza spazi) desiderato per il file video (senza estensione). Una volta terminato il download, il video verrà salvato nella vostra home con estensione MKV. Sebbene il contenitore sia Matroska, la codifica vera e propria di audio e video dipende soltanto dal sito web da cui scaricate, quindi potrebbe variare. In ogni caso con VLC e gli opportuni codec dovreste riuscire a visualizzare tutto e potete sempre convertire i video con Arista Transcoder.

Esempio di utilizzo dello script con una puntata di “Ris Roma” dal sito Video Mediaset

Note finali

Come ogni cosa, anche lo script ha i suoi limiti. Il download non si può mettere in pausa, perché il programma originale non lo permette, e ogni tanto succede che l’eseguibile sotto Wine vada in crash. In generale comunque funziona bene, e avendo aggiunto il calcolo della percentuale (non presente in origine) penso di averlo reso abbastanza gradevole anche dal punto di vista estetico. La codifica del video finale è un po’ un terno al lotto, ma quasi sempre non crea nessun problema con VLC.

L’unico difetto visibile dei video è la presenza sporadica di lievissime macchioline nere, ma a dire il vero non so se imputare la cosa al programma che si occupa del download oppure al sito web che fornisce i video. In definitiva comunque i risultati sono buoni e con una risoluzione niente male. Il prezzo da pagare è l’uso di Wine e di qualche componente proprietario, ma d’altronde abbiamo a che fare con tecnologie Microsoft ed è difficile evitarlo del tutto.

Spero di poter finire presto anche il post dedicato a “scovare gli URL” in modo da poter completare questa serie di articoli sul salvataggio dei video, che sembrano essere i più gettonati nel blog. Che ne pensate dello script? Vi tornerà utile?

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

dic
21

Integrare le applicazioni GTK+ in KDE

 

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 Stili e caratteri 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 filecp ~/.gtkrc-2.0-kde ~/.gtkrc-2.0 # per copiare il fileln -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

sudo cp ~/.gtkrc-2.0 ~root/.gtkrc-2.0 # per copiare il filesudo 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

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

ago
11

Compilare moduli del kernel con DKMS

 

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.

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

giu
26

Conflitto fra i moduli delle schede audio

 

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 esternablacklist snd_intel8x0

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

feb
26

Compilare GNU Octave 3.4.0

 

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.ccconfigure: 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 nativeconfigure: WARNING: graphics.  It isn t necessary to have native graphics,configure: WARNING: but you will need to have gnuplot installed or you won tconfigure: WARNING: be able to use any of Octave s plotting commandsconfigure: WARNING: configure: configure: NOTE: libraries may be skipped if a library is not found ORconfigure: 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

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

feb
20

Compilare QtiPlot 0.9.8.4

 

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-essentialsudo 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.bz2cd 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), della quale non ci occuperemo, e TAMUANOVA.

Vogliamo compilare QTeXEngine e TAMUANOVA. Salveremo i codici sorgenti di questi programmi 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.zipunzip QTeXEngine-0.3-opensource.zipcd QTeXEngine

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

qmakemake

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 TAMUANOVA e compiliamolo:

cd ..wget http://www.stat.tamu.edu/~aredd/tamuanova/tamu_anova-0.2.tar.gztar 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):

./configuremake

Controllate l exit status con echo $?. Se ottenete 0 potete andare avanti. Non è necessario installare la libreria, è sufficiente averla compilata.

Passiamo ora a QtiPlot. 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). 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 INCLUDEPATHSYS_INCLUDEPATH = /opt/local/include# Global lib path and libs which is ls always added at the end of LIBSSYS_LIBS = -L/opt/local/lib

############################################################ zlib (http://www.zlib.net/)########################################################### include path. leave it blank to use SYS_INCLUDEZLIB_INCLUDEPATH = $$QTI_ROOT/3rdparty/zlib/

############################################################ muParser (http://muparser.sourceforge.net/)########################################################### include path. leave it blank to use SYS_INCLUDEMUPARSER_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 installationGSL_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.dllunix:QWT3D_LIBS = $$QTI_ROOT/3rdparty/qwtplot3d/lib/libqwtplot3d.so

############################################################ 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 installationLIBPNG_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/# link locally against a copy in 3rdparty/# ALGLIB_LIBS = $$QTI_ROOT/3rdparty/alglib/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 = lupdateLRELEASE = 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

qmakemake

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 QtiPlot il comando

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”).

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

gen
15

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

 

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 Questo è 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” 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 e 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.

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

ott
26

Confrontare le differenze 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 1fipdf1=$1pdf2=$2txt1=$(dirname "$pdf1")/$(basename "$pdf1" .pdf).txttxt2=$(dirname "$pdf1")/$(basename "$pdf2" .pdf).txtconverti txt1 pdf1 && converti txt2 pdf2if [ $? -eq 0 ]; then    diff -u "$txt1" "$txt2" | lessfirm -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, diff-pdf, 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

diff-pdf /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 1fipdf1=$1pdf2=$2txt1=$(dirname "$pdf1")/$(basename "$pdf1" .pdf).txttxt2=$(dirname "$pdf1")/$(basename "$pdf2" .pdf).txtconverti txt1 pdf1 && converti txt2 pdf2if [ $? -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 1fiexit 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 (ricordo che la tilde ~ è un abbreviazione della cartella home dell utente corrente) chiamandolo, per esempio, diff-pdf. Rendete quindi eseguibile lo script. Così potrete selezionare due file PDF da confrontare e, facendo clic con il tasto destro, scegliete Script ? diff-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 esegui 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.

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

ott
18

Imparare ad usare il terminale Linux con CLI Companion

 

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

set
20

Creare un metapacchetto deb con equivs

 

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, consiste di 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 potete sostituire 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, 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). Per esempio in questi giorni ho installato la distribuzione TeX Live 2010 dal sito ma avevo la necessità di far credere ad APT che i pacchetti texlive e texlive-binaries fossero installati, per poter installare altri programmi dipendenti da questi. Per fare ciò ho creato il file texlive con il seguente contenuto:

Section: misc
Priority: optional
Homepage: http://tug.org/texlive/
Standards-Version: 2010

Package: texlive
Version: 2010
Provides: texlive,texlive-latex-base
Maintainer: me
Architecture: all
Description: Texlive dummy package

e texlive-binaries con il seguente contenuto:

Section: misc
Priority: optional
Homepage: http://tug.org/texlive/
Standards-Version: 2010

Package: texlive-binaries
Version: 2010
Provides: texlive-binaries,texlive-base-bin
Maintainer: me
Architecture: all
Description: texlive-binaries dummy package

e con i comandi

equivs-build texlive
equivs-build texlive-binaries

ho generato i pacchetti deb che ho potuto installare con un doppio clic.

Come spiegato nella documentazione (in particolare nel manuale di equivs-build), se si riscontra qualche caso in cui il sistema delle dipendenze dei pacchetti dovrebbe essere migliorato, non usare equivs ma piuttosto segnalare agli sviluppatori il problema.

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

set
20

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

 

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.

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

set
18

Download via terminale con WGET

 

Popularity: unranked [?]



Puoi visualizzare il post originale qui.

lug
18

Come si installa un .tar.gz?

 


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.

Popularity: 1% [?]



Puoi visualizzare il post originale qui.

top