Indice generale
1. INTRODUZIONE......................................................................1
2 CONTESTO SCIENTIFICO E TECNOLOGICO.............................7
2.1 OpenDocument..................................................................7
2.1.1 OpenDocument Format................................................7
2.1.2 OpenDocument Text....................................................9
2.2 PDF..................................................................................11
2.3 XSL­FO............................................................................15
2.3.1 Il processore Apache FOP..........................................16
2.3.2 XSL­FO Converter......................................................16
2.3.3 HTML2FO..................................................................17
2.4 OpenOffice.org..................................................................18
2.5 Convertitori on­line...........................................................22
2.6 Conversione in formato .doc..............................................25
2.6.1 PDFCreator................................................................25
2.6.2 PrimoPDF..................................................................27
2.7 CUPS­PDF........................................................................29
3 PROTOTIPO O2PX..................................................................33
3.1 Contenuto di un documento.............................................34
3.2 Conversione da XML a XSL­FO ........................................36
3.2.1 Pagine........................................................................37
3.2.2 Il testo.......................................................................39
3.2.3 Le tabelle...................................................................43
3.2.4 Le immagini...............................................................46
3.2.5 Intestazioni e piè di pagina.........................................47
3.2.6 Footnotes...................................................................49
3.3 Problemi dell'approccio in XSL­FO....................................51
3.3.1 Ancoraggio delle immagini..........................................51
3.3.2 Divisione di una pagina in colonne ............................52
3.3.3 Allineamento Tabelle..................................................52
3.3.4 Posizionamento delle immagini...................................52
3.3.5 Tabelle.......................................................................53
3.4 Conversione di ODT in PDF...............................................53
4 ARCHITETTURA DEL CONVERTITORE O2PX..........................59
4.1 Sviluppo del progetto........................................................59
4.1.1 XSLT.........................................................................62
4.2 Il processore Java.............................................................63
4.3 Documento XSLT..............................................................65
4.3.1 Definizione degli stili di pagina...................................65
4.3.2 Definizione dell'intestazione e del piè di pagina...........68
4.3.3 Definizione dei paragrafi di testo.................................69
4.3.4 Definizione delle tabelle..............................................71
4.3.5 Definizione delle immagini e delle cornici....................72
4.3.6 Definizione degli elenchi puntati.................................73
4.4 Problemi e bug..................................................................74
4.4.1 Tabelle.......................................................................74
4.4.2 Intestazioni e piè di pagina.........................................75
4.4.3 Metadati....................................................................76
4.4.4 Allineamento del testo dei paragrafi............................76
4.4.5 Font Family...............................................................76
4.4.6 Float..........................................................................77
4.4.7 Campi dinamici..........................................................77
5 CONCLUSIONI........................................................................79
Biblografia..................................................................................83
Indice delle illustrazioni..............................................................85
1. INTRODUZIONE
Lo scopo di questa tesi è quello di dimostrare che è possibile convertire in PDF un qualunque documento di testo in formato ODT, passando per XSL­FO. Per dimostrare tale affermazione, in questa tesi viene presentato il progetto O2PX (ODT to PDF by XSL­FO). Il progetto nasce con l'intento di fornire uno strumento portabile e stand­alone per la presentazione di documenti OpenOffice.org. Deve, infatti, poter essere facilmente utilizzato sul proprio computer, indipendentemente dal sistema operativo utilizzato, ma, a differenza di OpenOffice.org, deve anche dare la possibilità di essere utilizzato da remoto. Inoltre l'utilizzo del formato intermedio XSL­FO rende il progetto modulare, poiché dal formato XSL­FO possono essere ricavati in output formati differenti dal PDF.
Il formato ODT, OpenDocument text, è un formato non proprietario, sezione dello standard ODF (OpenDocument Format, ISO/IEC 26300) [ISO06]. Il file di testo è strutturato come un archivio, e contiene al suo interno documenti XML (eXtensible Markup Language) e directory.
Un utente può avere la necessità di trasformare il proprio documento di testo ODT in PDF (Portable Document Format), poiché questo tipo di file è un formato universale che mantiene 1
tutti i caratteri, la formattazione, i colori e le immagini del documento di origine, indipendentemente dall’applicazione e dalla piattaforma utilizzate per crearlo. In genere, possono essere convertiti in PDF diversi tipi di file, nel caso di un documento di testo vengono mantenuti tutti gli aspetti presentazionali definiti nel file di testo, e quindi il documento non avrà differenze di rappresentazione dalla visualizzazione a schermo alla stampa.
Come detto, la trasformazione da ODT a PDF, nel progetto O2PX, è effettuata attraverso due passaggi. Durante il primo passaggio il documento di testo viene convertito in XSL­FO (XSL Formatting Object), mentre nel secondo passaggio questo formato viene trasformato in PDF. XSL­FO è un linguaggio di markup basato su XML e appartenente alla famiglia XSL, che specifica una semantica di formattazione per documenti XML [W3C06b].
Il passaggio al formato intermedio XSL­FO è conveniente poiché durante il primo passaggio viene effettuata la conversione tra due documenti XML. Questo tipo di conversione risulta più facile da gestire rispetto a dover trasformare direttamente il documento di testo in PDF. Inoltre esistono già tool che permettono di convertire documenti dal formato XSL­FO a quello PDF, e alcuni di questi programmi permettono di poter ottenere in output un formato di documento diverso dal PDF. Infatti è possibile ottenere anche file PostScript e SVG, perché è sufficiente cambiare il secondo passaggio della trasformazione. C'è da considerare anche che, se si utilizzano i tool già esistenti, il costo del secondo passaggio è pari a zero. 2
La conversione, dal documento ODT a XSL­FO, nel primo passaggio è effettuata attraverso un foglio di stile XSLT (eXtensible Stylesheet Language Transformations). L'utilizzo della tecnologia XSLT rende il convertitore altamente portabile. Infatti la trasformazione da ODT a XSL­FO può essere eseguita su qualsiasi architettura e sistema operativo, purché sulla macchina sia presente il processore XSLT 1.0.
Il secondo passaggio della conversione, invece, è affidato al tool Apache FOP. E' un processore XSL­FO, implementato in Java, che permette di ottenere in output diversi formati di documenti, tra cui il formato PDF. In O2PX Viene utilizzata la versione 0.94, l'ultima attualmente rilasciata.
Si è scelto di realizzare la parte relativa all'organizzazione e all'interazione dei processori XSLT e XSL­FO nel linguaggio Java, perché questo consente di soddisfare alcuni degli obiettivi iniziali. Il progetto è stato sviluppato per funzionare sia in locale che da remoto, ed inoltre viene eseguito direttamente, pertanto non comporta uno spreco di risorse, in quanto non deve interfacciarsi con nessun'altra applicazione.
Per poter effettuare la conversione di tipo si decomprime il documento testuale passato in input, ottenendo così i file XML al suo interno. Di questi vengono presi solo due documenti che contengono le informazioni sullo stile e il contenuto del documento ODT.
Tali file vengono uniti in un unico documento XML, e questo viene passato ad un processore XSLT, insieme al foglio di stile. Questo 3
processore provvede a modificare la struttura del documento XML che gli è stato passato, applicando le regole contenute nel foglio di stile scritto in XSLT. Dalla trasformazione si ottiene il documento in formato XSL­FO.
La trasformazione finale in PDF avviene grazie al processore Apache FOP, il quale si occupa di effettuare la conversione dal formato XSL­FO al formato di file che si desidera ottenere in output. Nel prossimo capitolo verrà illustrato il contesto scientifico tecnologico che sta intorno alla necessità di creare una applicazione di questo tipo, analizzando i formati di documenti con cui si lavora, ODT, PDF e XSL­FO, da cosa sono costituiti, e i programmi attualmente presenti che effettuano la conversione dei formati di documento. Nel terzo capitolo si descriverà il progetto ad alto livello, cioè senza soffermarsi sugli aspetti tecnici che ne stanno alla base, si spiegherà brevemente come viene effettuata la trasformazione e come funziona il programma, verranno mostrati degli esempi di trasformazione di documento ODT in PDF, e si parlerà delle limitazioni dovute all'approccio. Ovvero delle limitazioni dovute alla scelta di convertire verso XSL­FO.
Poi, nel quarto capitolo, ci si soffermerà sul lato tecnico, con una descrizione dettagliata delle tecnologie che sono state utilizzate, delle scelte effettuate, del foglio XSLT, e del programma Java, illustrando le classi di cui è composto. Inoltre saranno analizzati i problemi e i bug riscontrati.
4
Infine, nell'ultimo capitolo, verranno elencati gli obiettivi raggiunti, le considerazioni finali, i possibili miglioramenti e modifiche che possono essere apportati, e gli sviluppi futuri che tale applicazione può avere. 5
6
2 CONTESTO SCIENTIFICO E TECNOLOGICO
2.1 OpenDocument
O2PX consiste nella trasformazione di un documento di testo in PDF. Il documento di testo che viene utilizzato è in formato ODT, OpenDocument text, un formato non proprietario, parte dello standard ODF (OpenDocument Format, ISO/IEC 26300) [ISO06].
2.1.1 OpenDocument Format
Il formato OpenDocument (ODF) è basato su XML, meta­linguaggio di markup, cioè un linguaggio che permette di definire altri linguaggi di markup, e fornisce un insieme standard di regole sintattiche per modellare la struttura di documenti e dati [W3C06a]. L'ODF è uno "standard aperto", libero pertanto da restrizioni tecniche e da diritti d’autore del produttore.
Per definizione uno standard si dice aperto quando [UNI07]:
●
è adottato e mantenuto da un’organizzazione non­profit ed il cui sviluppo avviene sulle basi di un processo decisionale aperto e a disposizione di tutti gli interlocutori interessati e le cui decisioni vengono prese per consenso o a maggioranza;
●
il documento di specifiche è disponibile liberamente oppure ad un costo nominale. Deve essere possibile farne copie, 7
riusarle e distribuirle liberamente senza alcun costo aggiuntivo;
●
eventuali diritti di copyright, brevetti o marchi registrati sono irrevocabilmente concessi sotto forma di royalty­free;
●
non è presente alcun vincolo al riuso, alla modifica e all’estensione dello standard.
Il formato ODF risponde a tutti questi requisiti: l’adozione di tale modello fa in modo che le informazioni contenute nei file OpenDocument siano accessibili a prescindere dai sistemi operativi, dai programmi e dalle tecnologie utilizzati dagli utenti.
Chiunque può usare i file ODF su qualsiasi piattaforma in qualsiasi momento.
Questo formato è stato sviluppato dal consorzio di industrie OASIS (Organization for the Advancement of Structured Information Standards) ed è stato approvato come standard il 23 maggio 2005 [OAS05]. Il gruppo ha deciso di erigerlo su una versione precedente del formato OpenOffice.org, essendo questo già un formato XML con la maggior parte delle proprietà desiderate. Si deve precisare che OpenDocument non è uguale al vecchio formato OpenOffice.org; sono state introdotte molte modifiche derivate da esperienze sul campo, alcune basate sul feedback fornito da molti singoli utilizzatori ed organizzazioni.
Le estensioni più comuni di questo standard sono:
8
●
ods, fogli di calcolo;
●
odp, presentazioni;
●
odg, grafica;
●
odb, database;
●
odt, documenti di testo, ossia il formato utilizzato in questo progetto.
Tutte hanno in comune le iniziali od, per sottolineare che si tratta di OpenDocument, mentre la terza lettera serve per identificare il formato di file.
2.1.2 OpenDocument Text
Ogni documento di tipo odt è composto da fogli xml successivamente compressi. In pratica questo formato, come tutti i formati OpenDocument, è un archivio Zip. Decomprimendolo si ottengono vari file che descrivono le caratteristiche e il contenuto del documento di testo [OAS07]. La struttura è illustrata dalla seguente immagine:
Illustrazione 1: Struttura di un documento ODT
9
●
content.xml racchiude il contenuto del documento, ossia il testo, e alcune delle caratteristiche di presentazione, come, per esempio, le tabulazioni.
●
styles.xml contiene la maggior parte delle caratteristiche di presentazione del documento odt. Contiene infatti lo stile dei paragrafi, lo stile delle pagine, lo stile dei caratteri, lo stile dei frame, lo stile delle liste. Definendo lo stile delle pagine, vengono definiti, se presenti, lo stile e il contenuto delle intestazioni e dei piè di pagina. Gli effetti presentazionali e il contenuto del documento sono stati definiti in documenti diversi per dare più flessibilità.
●
meta.xml contiene i metadati del file, ossia le meta­informazioni, come ad esempio la versione di OpenOffice.org utilizzata, la data di creazione, l'utente che ha creato il documento e il tempo impiegato per editarlo. ●
mimetype è un file di una sola linea contenente il tipo MIME del documento; è necessario poiché la semplice estensione del file non basta per rendere il file riconoscibile, essendo solo un modo semplice per permettere all'utente di individuare velocemente il file.
●
settings.xml contiene le informazioni specifiche dell'applicazione; sono informazioni che non hanno niente a che fare con il contenuto o con gli effetti di presentazione. Alcune impostazioni, come ad esempio le informazioni sulla dimensione e la posizione della finestra, le impostazioni di stampa, sono comuni a molti documenti, altre invece dipendono dal tipo di documento, ad esempio per i file di 10
testo sono registrate informazioni come quelle relative al fattore di zoom, e se l'intestazione e il piè di pagina sono visibili.
●
Pictures è la directory contenente le figure presenti all'interno del documento odt.
●
Thumbnails racchiude le immagini di anteprima del documento.
●
META­INF
contiene
un
documento
generato automaticamente, il manifest.xml, che definisce la struttura del documento. ●
Configurations2 compaiono le impostazioni del programma, ad esempio le barre di applicazione.
Lo scopo della tesi, come è stato detto precedentemente, è di trasformare un odt in PDF, è quindi necessario osservare le caratteristiche tecniche di questo formato.
2.2 PDF
Il formato PDF (Portable Document Format), creato da Adobe System Inc. nel 1990, permette di mantenere inalterati i documenti con il loro contenuto (caratteri, immagini, 11
impaginazione, formattazione e altro ancora) indipendentemente dalla piattaforma che viene usata per crearli o per leggerli [ADO06]. Eredita molte delle funzionalità del PostScript (ps), un linguaggio di descrizione della pagina anch'esso sviluppato da Adobe. Postscript permette di descrivere una pagina come il risultato di un'esecuzione di un programma, che contiene istruzioni su come e dove disegnare linee, punti, lettere dell'alfabeto e altri elementi grafici. In questo modo, ogni apparecchio capace di eseguire il programma (ossia, che abbia un interprete Postscript), sarà in grado di riprodurre tale immagine.
PDF, invece, è un formato, non un linguaggio di programmazione, pertanto non necessita di essere interpretato; è una combinazione di grafica vettoriale, testo e grafica per punti, e supporta collegamenti (interni ed esterni), moduli, javascript ed oggetti 3D. Le caratteristiche fondamentali dei file in formato PDF sono [ADO08a]:
●
Multipiattaforma: Un documento PDF risulta visualizzabile, leggibile e stampabile da qualsiasi sistema operativo, sia esso Windows, Macintosh, Unix, SUN, HP. ●
Integrità delle informazioni: I file PDF hanno esattamente lo stesso aspetto dei documenti originali e mantengono inalterate le informazioni dei file sorgente così come sono stati creati dall’autore (testo, disegni, grafica a colori, addirittura
business
logic),
indipendentemente dall'applicazione utilizzata per crearli. ●
12
Stampabile: il formato PDF permette di inviare il documento direttamente in tipografia, poiché il documento stampato sarà uguale al documento che viene visualizzato a schermo. La visualizzazione e, successivamente, la stampa seguiranno perfettamente il layout originale riproponendo in maniera identica le immagini, l’impaginazione, gli stili ed i font adottati.
●
Sicurezza: ogni documento in PDF può essere criptato da password o da firma digitale in modo che vi possano accedere solo gli utenti autorizzati. Ci sono diversi livelli di protezione, ad esempio i documenti possono essere stampabili o non stampabili, protetti da password, e la selezione del testo può essere bloccata o non bloccata. ●
Allegati: si possono creare dei link a filmati, suoni o ad altri documenti.
●
Collegamenti: all’interno di un documento in PDF è possibile creare dei link che rimandano ad altri documenti (da inserire nella cartella del lavoro) realizzati con qualsiasi programma ed anche a siti web in linea. ●
Password: è possibile inserire nel salvataggio del documento in PDF, una password che consente di vietare la manomissione del documento stesso pur lasciando la facoltà di farlo leggere e stampare. ●
Indicizzazione: nel caso il documento abbia più pagine da visualizzare, è possibile creare un indice che collega ad ogni pagina o a parte di esso. ●
Condivisione: il formato PDF è stato creato per condividere al 100% qualsiasi file su qualsiasi computer. I documenti PDF 13
possono essere caricati su siti web, trasmessi per posta elettronica, o inseriti su CD. E' sufficiente che il lettore abbia installato un programma in grado di leggere questo tipo di file.
●
Funzionalità di ricerca: Le funzioni di ricerca full­text consentono di individuare termini, segnalibri e campi di dati all'interno dei documenti.
●
Accessibilità: I documenti PDF utilizzano tecnologie di supporto per rendere le informazioni accessibili alle persone disabili.
La possibilità di poter essere letti su ogni sistema operativo e l'indipendenza dal software utilizzato per crearlo, ha reso il formato PDF uno strumento usatissimo per condividere documenti che devono mantenere immutate le loro caratteristiche. Fin dagli anni '90 è divenuto il formato file standard per l'interscambio di documenti.
Lo standard PDF è uno standard aperto. Tutti hanno la possibilità di creare applicazioni che permettano la visualizzazione, la lettura e la creazione di file PDF senza pagare i diritti alla Adobe Systems. 14
2.3 XSL-FO
La trasformazione da ODT a PDF viene effettuata attraverso un passaggio intermedio, ovvero la creazione di un file in formato XSL­FO. Questo è un documento in cui vengono definite le regole di impaginazione delle informazioni che si vogliono visualizzare, andando ad esprimere la posizione dei singoli contenuti nella pagina. L'XSL­FO è un linguaggio di markup basato su XML e appartenente alla famiglia XSL, che specifica una semantica di formattazione per documenti XML [W3C06b]. In genere un documento in formato FO è costituito da 2 sezioni fondamentali: la prima sezione contiene la definizione e i dettagli del page layout, mentre la seconda contiene il contenuto del documento con il relativo stile.
Il page layout definisce le proprietà della pagina. In esso sono definiti lo stile e i margini della pagina, le informazioni relative alla modalità di scrittura, e in alcuni casi la sequenza delle pagine.
Mentre la sezione relativa al testo è divisa in flow, ognuno è collegato ad un layout di pagina. I flow contengono gli header e i footer, se presenti, e il corpo della pagina. Questi elementi sono costituiti da blocchi. Ogni blocco contiene il testo del documento con lo stile che deve essere applicato ad esso.
Una volta creato il documento in formato XSL­FO, questo può essere passato ad un processore FO, che converte il file ricevuto in 15
input in un qualsiasi formato leggibile e stampabile. I formati più comunemente ottenuti da questa trasformazione sono il PDF e il PS (PostScript). Esistono diversi tool che prendo in input un documento in formato XSL­FO e restituisco in output file in formati diversi, ai fini del progetto è stato utilizzato Apache FOP.
2.3.1 Il processore Apache FOP
FOP (Formatting Object Processor) è una libreria Java creata dalla Apache Foundation, che permette di generare diverse tipologie di documenti. Questa libreria si basa sulla tecnologia XSLT, ed in particolare sul linguaggio XSL­FO. E' un software open­source, distribuito sotto licenza Apache Software License [APA07].
Apache FOP legge un albero di contenuti XSL­FO e lo converte in formati di file direttamente stampabili, ossia file direttamente riconosciuti dalle stampanti, come ad esempio PDF e PS, e in altri formati, come SVG, XML, AWT, PNG, PCL, RTF, TXT. Viene utilizzata la versione 0.94, l'ultima attualmente rilasciata.
2.3.2 XSL-FO Converter
Un tool che lavora con XSL­FO è XSL­FO Converter [PIX07]. Questo, un programma della XMLmind, divisione della Pixware, è un convertitore realizzato per trasformare un file FO in diversi formati di documento, compatibili con i principali word processor. 16
I formati di output attualmente supportati sono RTF (Rich Text Format), ODF, OOXML (OpenOffice XML), WML (WordprocessingML).
Questo software è stato progettato per fornire un mezzo per la conversione, di documenti o dati XML, in formati di file adatti alla visualizzazione e modifica in editor di testo. XSL­FO Converter mantiene la struttura del documento di origine e tutte le informazioni di presentazione.
2.3.3 HTML2FO
HTML2FO è un tool che converte un documento in formato HTML in XSL­FO [HTM02]. Il documento in input non deve essere obbligatoriamente un XML ben formato.
Questo software può essere utilizzato su ogni piattaforma, e rappresenta correttamente i documenti, mantenendo le informazioni sul carattere, quali l'altezza, lo stile applicato e il colore, supporta le tabelle, tenendo conto del colspan, del rowspan, dello stile dei bordi e il background, e gestisce i link, sia interni che esterni. 17
2.4 OpenOffice.org
Ci sono vari programmi che offrono all'utente la possibilità di convertire un documento ODT in PDF. In questo capitolo ne verranno analizzati alcuni tenendo in considerazione i rispettivi pregi e difetti.
Il primo programma che si prende in considerazione è OpenOffice.org. Questo è una suite di software libero per l'automazione d'ufficio completa e gratuita [OOo05]. OpenOffice.org, la cui abbreviazione è OOo, è sia un software sia una comunità di volontari che produce e supporta tale software.
OOo ha l'obiettivo di fornire a tutti gli utenti un ottimo prodotto, libero e aperto, che possa competere con i prodotti commerciali dominanti in questo settore; comprende diversi componenti: un editor di testo (Writer), un elaboratore di fogli elettronici (Calc), un programma per le presentazioni multimediali (Impress), un elaboratore di grafica vettoriale (Draw), un programma per la creazione e la gestione di database (Base) e un elaboratore di formule (Math). I vantaggi di questa suite, rispetto alle altre suite da ufficio sono:
●
Nessun costo di licenza. OOo è liberamente utilizzabile e distribuibile da chiunque senza alcun costo. Molte caratteristiche sono liberamente fruibili in OOo, mentre in altre suite per ufficio sono disponibili come add­on a costi extra (un esempio è l'esportazione in formato PDF). Nessun 18
costo nascosto attuale o futuro.
●
Open source. Grazie alle licenze open source di OOo è possibile distribuire, copiare e modificare il software come si desidera.
●
Multipiattaforma. OOo, dalla versione 2.0, funziona su numerose architetture hardware e diversi sistemi operativi quali Microsoft Windows, Mac OS X, Linux e Sun Solaris.
●
Ampio supporto linguistico. L'interfaccia utente di OOo è disponibile in oltre 40 lingue e il progetto OOo offre correttori ortografici, di sillabazione e dizionari per oltre 70 lingue e dialetti. OOo fornisce inoltre supporto sia per le lingue con schema di testo complesso (Complex Text Layout ­ CTL) sia per le lingue con scrittura da destra a sinistra (Right to Left ­ RTL) come l'hindi, l'ebraico e l'arabo.
●
Interfaccia utente condivisa. L'interfaccia semplice e intuitiva comune a tutti i componenti rende il loro utilizzo semplice da imparare e padroneggiare.
●
Integrazione. I componenti di OpenOffice.org sono ben integrati l'uno con l'altro.
–
Tutti i componenti condividono un correttore ortografico e altri strumenti comuni, utilizzabili in maniera compatibile in tutta la suite. Ad esempio, lo strumento per il disegno disponibile in Writer è lo stesso presente in Calc e, con funzionalità più avanzate, in Impress e Draw.
–
Non è necessario sapere quale applicazione sia stata usata per creare un particolare file quindi, ad esempio, è possibile aprire un file Draw da Writer.
19
●
Modularità. In genere, se si modifica un'opzione, questa ha effetto su tutti i componenti, ma è comunque possibile configurare le opzioni di OOo a livello di componente o addirittura a livello di documento.
●
Compatibilità dei file. OOo offre funzioni di esportazione in formato PDF e Flash, come anche il supporto per l'apertura e il salvataggio dei file in formati diffusi come Microsoft Office, HTML, XML.
●
Nessun vincolo esclusivo con il produttore. OOo 2.0 utilizza il formato file OpenDocument, un formato file XML (eXtensible Markup Language) sviluppato come standard industriale da OASIS (Organization for the Advancement of Structured Information Standards). Tali file sono facilmente decomprimibili e leggibili con un qualsiasi editor di testo. La loro struttura è aperta e liberamente consultabile.
●
Interazione con l'utente. Miglioramenti, riparazione di bug e date di pubblicazione vengono definite dalla comunità. Si può entrare a far parte della comunità e contribuire allo sviluppo del prodotto che si utilizza.
Inoltre dalla versione 2.0 sono state aggiunte altre caratteristiche come ad esempio la possibilità di inserire la firma digitale, che consente l'autenticazione del vero autore o editore di documento, e la crittografia, che, grazie all'adozione di un nuovo algoritmo di crittografia XML, fornisce ulteriore sicurezza ai documenti.
Come visto in precedenza OpenOffice.org permette di esportare un documento in formato ODT in PDF, utilizzando una macro 20
gratuita disponibile al momento dell'installazione della suite. Illustrazione 2: OpenOffice.org, esportazione in formato PDF
Tale macro è molto efficiente e riproduce fedelmente il file ODT, però lo svantaggio è che per poter effettuare la trasformazione si deve per forza interagire con OpenOffice.org. Questo vuol dire che ogni volta che si vuole convertire un documento si deve avviare il programma, per poi effettuare la conversione vera e propria.
Questo comporta un consumo non indifferente delle risorse e non 21
è conveniente per applicazioni web. Infatti caricando la suite di programmi si occupano più risorse, ad esempio aree di memoria e consumo di CPU, di quelle che realmente servirebbero per effettuare la trasformazione, inoltre il programma e il documento da convertire devono essere presenti sulla stessa macchina, dato che ancora non è stata implementata una versione di OpenOffice.org che funzioni da remoto.
2.5 Convertitori on-line
In Internet si possono trovare alcuni programmi che effettuano la trasformazione tra i formati di documenti, e offrono la possibilità di ottenere il documento PDF da uno ODT.
Il primo ad essere analizzato è Zamzar, un convertitore di file online, gratuito, che non richiede alcuna registrazione, è semplice da utilizzare e può essere integrato sul proprio browser [ZAM07a]. I passi necessari per eseguire il programma sono i seguenti: si sceglie il file da convertire (è possibile caricare il file selezionando l'URL (Universal Resource Locator) o caricarlo da locale, l'unico requisito è che il documento non superi i 100 MB), si seleziona il formato di conversione [ZAM07b], si digita la propria e­mail e, infine, si procede con la conversione. Dopo poco tempo il file 22
ottenuto sarà recapitato nella propria casella e­mail. Zamzar offre la conversione di quattro tipi di documenti: testo, audio, video e immagini.
Illustrazione 3: Schermata del convertitore on­line ZamZar
L'altro programma on­line ad esser stato analizzato è Media Convert [MED06]. Questo permette di convertire vari formati di file, ad esempio archivi, audio, video o documenti. E' gratuito e non richiede nessuna installazione sul proprio computer.
Per poter effettuare la trasformazione si deve inserire, nella homepage del sito, il file da convertire, la cui dimensione non deve 23
superare i 150MB. Il programma caricherà automaticamente il formato del documento di input, e l'utente dovrà selezionare il formato di output, accettare i termini d'uso di tale applicazione e procedere. In pochi minuti il file viene convertito e si può effettuare il download del documento finale.
Illustrazione 4: Schermata del convertitore on­line MediaConverter Il fatto che questi programmi non richiedano l'installazione sul proprio computer consente di poterli utilizzare ovunque. Purtroppo è necessario essere connessi ad internet, e questo è il principale svantaggio poiché non c'è la possibilità di installare queste applicazioni sul proprio computer, rendendo di fatto impossibile la conversione di documenti.
24
2.6 Conversione in formato .doc
Verranno analizzati ora alcuni programmi che convertono in PDF solo documenti di testo aventi estensione .doc, file di formato proprietario prodotto da Microsoft Word. Come già detto, i documenti che si è interessati a convertire in questa tesi sono soltanto quelli in formato ODT, tuttavia la trasformazione è applicabile anche in casi come questi, anche se con passaggi più lunghi e macchinosi, poiché esistono applicazioni che consentono di convertire file dal formato ODT a quello .doc, come ad esempio è possibile fare con OpenOffice.org.
Ottenuto il file in formato .doc, è possibile convertirlo in PDF attraverso i programmi che verranno analizzati qui di seguito.
Naturalmente questa soluzione non è delle migliori, si è costretti, infatti, ad interfacciarsi con OpenOffice.org, o un'altra applicazione, per ottenere il file in formato .doc, che successivamente viene passato al programma che eseguirà la conversione nel formato che si desidera ottenere, con conseguente spreco di risorse.
2.6.1 PDFCreator
Il primo programma analizzato che permette di convertire un documento di testo .doc è PDFCreator [PDF06]. Questo è un software open source per piattaforma Windows che 25
consente di generate un file in formato PDF partendo da qualsiasi documento. Il programma è scritto nel linguaggio Visual Basic e dipende da alcuni componenti proprietari di Windows, e questo lo rende, di fatto, disponibile solo su questa piattaforma. La generazione vera e propria del file PDF è gestita da GhostScript, collezione di programmi liberi basata su un interprete dei linguaggi di descrizione di pagina come PostScript e PDF.
PDFCreator funziona come stampante virtuale, cioè lavora simulando di essere una stampante, in modo tale che qualsiasi programma con opzione di stampa darà la possibilità di creare file PDF. Vengono offerte due modalità di installazione: standard e server. La possibilità di convertire solo documenti in formato .doc e la disponibilità di tale programma solo in ambiente Windows lo rende svantaggioso, limitandone l'interoperabilità. Inoltre, poiché funziona come stampante virtuale, quindi non in modo autonomo, si è costretti a interfacciarsi con un altro programma per poter utilizzare PDFCreator. Questo comporta, come nel caso di OpenOffice.org uno spreco non indifferente di risorse e la difficoltà di utilizzarlo da remoto.
26
Illustrazione 5: Schermata del convertitore PDFCreator
2.6.2 PrimoPDF
Un programma simile a PDFCreator, che è stato appena analizzato, è PrimoPDF [ACT08].
Questo è un programma gratuito realizzato dalla ActivePDF [ACT07] in grado di convertire file di testo in PDF. Anche questo programma funziona come stampante virtuale.
Per eseguire la trasformazione si deve aprire il documento .doc da un programma che consente di stampare e scegliere come 27
stampante PrimoPDF, a video compare la finestra del programma nella quale è necessario indicare il percorso ed il nome del file (in automatico viene proposto il nome del file preceduto dal nome del programma di origine) nella casella di testo "Save As", e si possono eventualmente modificare le opzioni predefinite.
Illustrazione 6: Schermata del convertitore PrimoPDF
Questo programma mette a disposizione tre diverse qualità di risoluzioni da assegnare al file PDF. Inoltre è possibile indicare il titolo, l'autore, il contenuto, le chiavi di ricerca, eventuali protezioni, ad esempio assegnare una password per l'apertura del documento PDF e, se si vuole, una password per attribuire delle restrizioni al file.
La semplicità nell'utilizzo, la versatilità del software, ovvero la possibilità di stampare da qualsiasi applicativo in formato PDF e non ultima, la licenza freeware, sono gli evidenti pregi di 28
PrimoPDF. Per contro, PrimoPDF trasforma solo file in formato .doc, è supportato solo su piattaforma Windows e non consente di ottenere dei file “dinamici”, ovvero che permettano la navigazione al loro interno, ad esempio in presenza di link interni, segnalibri, indirizzi web. Le pagine realizzate in PDF possono essere lette soltanto in maniera sequenziale.
2.7 CUPS-PDF
Questi ultimi programmi che sono stati analizzati producono file PDF grazie all'utilizzo di stampanti virtuali, ma hanno la restrizione di convertire solo documenti di testo di formato proprietario della Microsoft.
Anche sulla piattaforma Unix c'è la possibilità di convertire, utilizzando la stampante virtuale, file di testo ODT in formato PDF. Questo avviene attraverso CUPS­PDF [CUP07a], interfaccia di CUPS (Common Unix Printing System) [CUP07b]. 29
Illustrazione 7: Schermata della stampante virtuale CUPS­PDF
Questo modulo gestisce lavori e code di stampa. Un computer con CUPS in esecuzione è in grado di accettare stampe da altri computer, elaborarle ed inviarle alla stampante richiesta. Il sistema è costituito da un filtro che converte i dati di stampa ricevuti in un formato accettato dalla stampante ed un modulo che invia i dati elaborati al dispositivo di stampa.
CUPS si basa sull'Internet printing protocol (IPP), basato su HTTP, per gestire l'invio dei dati e le code di stampa. Il principale vantaggio di CUPS è quello di essere un sistema modulare e standard, in grado quindi di operare con numerosi formati di dati e interfacciarsi con i diversi modelli di stampanti presenti sul mercato, ciascuno in grado di accettare un formato o un linguaggio specifico. Attraverso il protocollo Samba si ha la possibilità di accedere al servizio anche da ambienti Windows.
CUPS­PDF permette di “stampare” qualsiasi formato di documento 30
in PDF. Il difetto di tale applicazione, come fatto notare negli altri programmi basati su stampanti virtuali, è lo spreco di risorse causato dalla necessità di interfacciarsi con programmi di editor che permettano la stampa. 31
32
3 PROTOTIPO O2PX
Ai fini di questa tesi deve essere realizzato un convertitore che trasformi un documento di testo ODT in un documento in formato PDF. Questa trasformazione viene effettuata passando per il formato intermedio XSL­FO.
La conversione, infatti, viene svolta in due passaggi: da ODT si converte nel formato XSL­FO e, nel secondo passaggio, da XSL­FO si converte in PDF. Questo passaggio intermedio è conveniente poiché durante il primo passaggio viene effettuata la conversione tra due documenti in XML. Questo tipo di conversione risulta più facile da gestire rispetto a dover trasformare direttamente il documento in PDF. Inoltre esistono già dei tool che consentono di convertire un documento dal formato XSL­FO a quello PDF, e alcuni di questi programmi offrono la possibilità di ottenere in output formati di documenti differenti, come ad esempio PostScript o SVG. C'è da considerare anche che, se si utilizzano tool già esistenti, il costo del secondo passaggio è pari a zero.
La conversione da ODT a XSL­FO, nel primo passaggio, è effettuata attraverso un foglio di stile XSLT. L'utilizzo delle tecnologia XSL­FO e XSLT rende il progetto altamente modulare e portabile. Infatti è sufficiente cambiare il secondo passaggio della trasformazione per ottenere in output formati differenti dal PDF, inoltre la trasformazione da ODT a XSL­FO può essere eseguita su qualsiasi architettura e sistema operativo, purchè sulla macchina 33
sia presente il processore XSLT.
La conversione nel secondo passaggio è effettuata attraverso il tool Apache FOP. Questo è un processore XSL­FO che permette di ottenere in output diversi formati di documenti, tra cui il PDF.
Verranno ora illustrate alcune caratteristiche tipiche di un documento di testo, e come queste siano rappresentate in XSL­FO.
3.1 Contenuto di un documento
Gli elementi più comunemente utilizzati all'interno di un documento ODT sono: il testo, le tabelle, le immagini, le intestazioni e i piè di pagina.
Il testo può essere diviso in paragrafi, che possono essere caratterizzati da un proprio stile. Infatti può accadere di utilizzare differenti stili in una pagina, ad esempio il titolo di un documento avrà uno stile differente rispetto al corpo, inoltre possono essere presenti termini scritti in corsivo o grassetto.
Queste definizioni di stile determinano tutte le caratteristiche che devono essere rappresentate. Ogni definizione viene suddivisa nelle dichiarazioni dello stile dei paragrafi (ad esempio vengono definiti l'interlinea tra le righe, l'allineamento del testo) e dello stile del testo (in cui compare il font del carattere, la dimensione, la sottolineatura, il grassetto, il corsivo).
34
Le tabelle, invece, sono caratterizzate dallo stile, dalla sua dimensione, dall'altezza, dal numero di righe e colonne. Questa definizione di stile è strutturata: ●
si ha un modello per la struttura della tabella, in cui vengono specificati la larghezza, il margine destro, quello sinistro, l'allineamento e il colore di sfondo della tabella;
●
una dichiarazione per lo stile delle colonne, nella quale si determina la larghezza della colonna stessa;
●
una descrizione dello stile delle righe, in cui si precisa l'altezza minima;
●
una definizione dello stile delle celle, dove vengono indicati i bordi della tabella, il padding e il colore di sfondo.
Lo stile che viene associato ad un'immagine racchiude al suo interno la definizione dell'allineamento verticale, di quello orizzontale, e la dimensione dell'immagine. Infatti, quando viene inserita una figura nel documento, le sue dimensioni possono essere modificate, allargandola o restringendola. Le modifiche che possono essere apportate ad un'immagine non tengono in considerazione la proporzione, quindi può accadere che la figura sia più larga di quella originale, ma senza che venga modificata l'altezza dell'immagine stessa.
Un documento, inoltre, può contenere al suo interno un'intestazione e un piè di pagina, e questi due elementi non devono essere obbligatoriamente presenti entrambi, possono anche non comparire affatto. Se presenti viene associato ad ognuno di essi uno stile in cui vengono definiti i margini e l'altezza minima associata a tale elemento.
35
Gli elementi che finora abbiamo analizzato, e non solo, sono tutti contenuti in pagine del documento ODT. Anche queste pagine hanno associato uno stile che ne dichiara le proprietà: la larghezza e l'altezza della pagina, modo di scrittura, se dall'alto verso il basso e se da sinistra a destra, ed inoltre vengono definiti i margini della pagina, all'interno dei quali verrà contenuto il corpo del documento.
I vari modelli di stili, appena descritti, costituiscono gli aspetti presentazionali di ogni elemento. Per poter ricavare un documento PDF corrispondente al file ODT di partenza si devono tenere in considerazione tutti questi aspetti e il contenuto del relativo oggetto.
3.2 Conversione da XML a XSL-FO
Si può analizzare più da vicino come la struttura del documento ODT possa essere convertita in un documento XSL­FO.
In styles.xml vengono definiti tutti gli stili, dalla definizione delle caratteristiche della pagina alla definizione degli stili dei paragrafi; mentre in content.xml è racchiuso il contenuto del documento.
Verranno ora analizzate alcune trasformazioni dei documenti ODT.
36
3.2.1 Pagine
Il primo elemento del documento ODT ad essere analizzato è il modello dalla pagina. La definizione di questo oggetto è specificata nel documento styles.xml. Qui vengono specificati sia le caratteristiche presentazionali della pagina in questione, sia il contenuto delle intestazioni e dei piè di pagina se presenti.
Nel documento XML la definizione del modello di pagina è contenuta all'interno del nodo <office:automatic­styles>, in esso possono essere contenute più dichiarazioni di pagina.
Un esempio di stile di pagina viene illustrato dall'immagine che segue.
37
<office:automatic­styles>
<style:page­layout style:name="pm1">
<style:page­layout­properties fo:page­width="8.2673in" fo:page­height="11.6925in" style:num­format="1" style:print­orientation="portrait" fo:margin­top="0.7874in" fo:margin­bottom="0.7874in" fo:margin­left="0.7874in" fo:margin­right="0.7874in" style:writing­mode="lr­tb" style:footnote­max­height="0in">
<style:footnote­sep style:width="0.0071in" style:distance­before­sep="0.0398in”
style:distance­after­sep="0.0398in" style:adjustment="left"
style:rel­width="25%" style:color="#000000"/>
</style:page­layout­properties>
<style:header­style/>
<style:footer­style/>
</style:page­layout>
<....>
</office:automatic­styles>
<office:master­styles>
<style:master­page style:name="Standard" style:page­layout­name="pm1"/>
<....>
</office:master­styles>
Definizione di una pagina in XML
In questa definizione vengono specificate tutte le caratteristiche che deve possedere la pagina, in questo caso non sono presenti né l'intestazione né il piè di pagina, perché altrimenti gli stili di questi elementi sarebbero stati contenuti all'interno di <style:header­
style> e <style:footer­style>, mentre il contenuto sarebbe stato all'interno del <style:master­page>. Il codice XSL­FO che rappresenta la struttura di questa pagina è:
38
<fo:layout­master­set>
<fo:simple­page­master master­name="Standard"
page­height="11.6925in" page­width="8.2673in"
margin­top="0.7874in" margin­bottom="0.7874in" margin­left="0.7874in"
margin­right="0.7874in" writing­mode="lr­tb">
<fo:region­body margin­top="0.1cm" margin­bottom="0.1cm"/>
<fo:region­before extent="2cm" region­name="Standard­before"/>
<fo:region­after extent="1cm" region­name="Standard­after"/>
</fo:simple­page­master>
<....>
</fo:layout­master­set>
Definizione di una pagina in XSL­FO
Le definizioni della pagina sono contenute all'interno dell'elemento <fo:layout­master­set>, al suo interno sono dichiarati i modelli delle pagine. All'interno di ogni modello sono contenuti la dimensione della pagina, la definizione dei margini, la modalità di scrittura e vengono specificate le regioni da cui è composta una pagina: il corpo del documento, la region­before e la region­after. Queste due regioni sono chiamate così perché sono elementi generici, infatti indicano il margine superiore e quello inferiore in una scrittura da sinistra a destra e dall'alto verso il basso, ma in una scrittura da destra a sinistra e dal basso verso l'alto esse si riferiscono al margine destro e sinistro.
3.2.2 Il testo
Il contenuto principale di un documento è il testo. La sua definizione è presente all'interno del documento content.xml, 39
mentre maggior parte delle caratteristiche presentazionali sono all'interno di styles.xml.
40
<office:document­content>
<office:automatic­styles>
<style:style style:name="P1" style:family="paragraph"
style:parent­style­name="Contents">
<style:paragraph­properties fo:text­align="left" style:justify­single­word="false"/>
<style:text­properties style:font­name="Bitstream Vera Sans"
fo:font­size­complex="11pt"/>
</style:style>
<...>
</office:automatic­styles>
<office:body>
<office:text>
<text:p text:style­name="P1">Data </text:p>
<...>
</office:text>
</office:body>
</office:document­content>
<office:document­styles>
<office:styles>
<style:default­style style:family="paragraph">
<style:paragraph­properties style:line­break="strict"
fo:hyphenation­ladder­count="no­limit"
style:writing­mode="page"/>
<style:text­properties style:font­name="Thorndale" fo:font­size="12pt" fo:language="en" fo:country="US"
style:country­complex="none" fo:hyphenate="false"
fo:hyphenation­remain­char­count="2" fo:hyphenation­push­char­count="2"/>
</style:default­style>
<style:style style:name="Standard" style:family="paragraph"
style:class="text"/>
<style:style style:name="Contents" style:family="paragraph" style:parent­style­name="Standard" style:class="extra">
<style:paragraph­properties fo:margin­top="0cm" fo:margin­bottom="0.212cm"/>
</style:style>
<....>
</office:styles>
</office:document­styles>
Definizione del testo del documento, con il relativo stile
41
Come si può vedere in questo esempio, il testo è all'interno del nodo <text:p>, questo ha associato uno stile che ne definisce tutte le caratteristiche presentazionali.
La rappresentazione di questo testo in XSL­FO è la seguente:
<fo:page­sequence master­reference="Standard">
<fo:flow flow­name="xsl­region­body">
<fo:block white­space­treatment="preserve" line­height="normal"
font­family="Bitstream Vera Sans, sans­serif" font­size="11pt"
margin­top="0cm" margin­bottom="0.212cm" text­align="center"
language="en" country="US" hyphenate="false"
hyphenation­push­character­count="2"
hyphenation­remain­character­count="2"
hyphenation­ladder­count="no­limit">Data </fo:block>
<...>
</fo:flow>
</fo:page­sequence>
Definizione di testo in XSL­FO
Dopo la dichiarazione delle pagine, si inserisce per ogni modello di pagina, il suo contenuto. In questo esempio la pagina “Standard” contiene al suo interno, nel corpo del documento, il testo “Data”. Il testo è inserito in un elemento <fo:block>, il quale definisce al suo interno tutte le caratteristiche che deve possedere. Questo nodo definisce i paragrafi, infatti ogni paragrafo è contenuto in un fo:block, al suo interno è possibile trovare l'elemento <fo:inline>. Esso è usato quando viene applicato uno stile diverso, da quello usato, ad una parola o a parte del testo del paragrafo. 42
3.2.3 Le tabelle
La definizione delle tabelle presenti nel testo è contenuta in content.xml.
<table:table table:name="Tabella1" table:style­name="Tabella1">
<table:table­column table:style­name="Tabella1.A" table:number­columns­repeated="3"/>
<table:table­column table:style­name="Tabella1.D"/>
<table:table­header­rows>
<table:table­row>
<table:table­cell table:style­name="Tabella1.A1" office:value­type="string">
<text:p text:style­name="Table_20_Heading"> Colonna 1</text:p>
</table:table­cell>
<table:table­cell table:style­name="Tabella1.A1" office:value­type="string">
<text:p text:style­name="Table_20_Heading">Colonna 2</text:p>
</table:table­cell>
<...>
</table:table­row>
</table:table­header­rows>
<table:table­row>
<table:table­cell table:style­name="Tabella1.A2" office:value­type="string">
<text:p text:style­name="P3">Prima riga (1,1)</text:p>
</table:table­cell>
<table:table­cell table:style­name="Tabella1.A2" office:value­type="string">
<text:p text:style­name="P3">Prima riga(1,2)</text:p>
</table:table­cell>
<...>
</table:table­row>
<table:table­row>
<table:table­cell table:style­name="Tabella1.A2" office:value­type="string">
<text:p text:style­name="P4">Seconda riga(2,1)</text:p>
</table:table­cell>
<table:table­cell table:style­name="Tabella1.A2" office:value­type="string">
<text:p text:style­name="P4">Seconda riga(2,2)</text:p>
</table:table­cell>
<...>
</table:table­row>
</table:table>
Definizione di una tabella in XML
43
All'interno del corpo del documento viene inserita la tabella, organizzata in righe e colonne. Gli attributi table:name e table:style­name richiamano gli stili applicati alla tabella. Questi stili sono definiti, sempre all'interno di content.xml, nell'elemento <office:automatic­styles>, e in essi sono dichiarati la larghezza della tabella e delle colonne, i margini e i bordi.
Il nodo <table:table> racchiude al suo interno la struttura della tabella. Viene definito il numero di colonne e lo stile che viene applicato ad esse. Poi per ogni riga viene specificato il contenuto delle celle al suo interno.
La struttura in XSL­FO è simile, la tabella è definita dal nodo <fo:table>, al suo interno sono specificate le colonne e le righe, al cui interno sono contenute le definizioni delle celle e del loro contenuto. Gli stili della tabella, delle colonne, delle righe e delle celle sono inseriti come attributi nei vari nodi.
La tabella XML, appena vista, viene così convertita in XSL­FO: 44
<fo:table width="16.999cm" table­layout="fixed">
<fo:table­column column­number="1" number­columns­repeated="3"
column­width="4.249cm"/>
<fo:table­column column­number="4" column­width="4.251cm"/>
<fo:table­header>
<fo:table­row>
<fo:table­cell column­number="1" padding="0.097cm"
border­left="0.002cm solid #000000" border­right="none"
border­top="0.002cm solid #000000" border­bottom="0.002cm solid #000000">
<fo:block ....>Colonna 1</fo:block>
</fo:table­cell>
<fo:table­cell column­number="2" ....>
<fo:block ....>Colonna 2</fo:block>
</fo:table­cell>
</fo:table­row>
</fo:table­header>
<fo:table­body>
<fo:table­row>
<fo:table­cell column­number="1" padding="0.097cm"
border­left="0.002cm solid #000000" border­right="none"
border­top="none" border­bottom="0.002cm solid #000000">
<fo:block ....>Prima riga (1,1)</fo:block>
</fo:table­cell>
<fo:table­cell column­number="2" ....>
<fo:block ....>Prima riga(1,2)</fo:block>
</fo:table­cell>
</fo:table­row>
<fo:table­row>
<fo:table­cell column­number="1" padding="0.097cm"
border­left="0.002cm solid #000000" border­right="none"
border­top="none" border­bottom="0.002cm solid #000000">
<fo:block ....>Seconda riga(2,1)</fo:block>
</fo:table­cell>
<fo:table­cell column­number="2" ....>
<fo:block ....>Seconda riga(2,2)</fo:block>
</fo:table­cell>
<....>
</fo:table­row>
</fo:table­body>
</fo:table>
Definizione della tabella in XSL­FO
45
3.2.4 Le immagini
Un documento ODT può contenere delle immagini. Queste possono essere inserite all'interno del corpo, dell'header e del footer del documento.
Se l'immagine è inserita dentro il body, allora la dichiarazione del suo stile è presente nel documento content.xml, altrimenti sarà contenuta in styles.xml.
<text:p text:style­name="P1">
<draw:frame draw:style­name="fr1" draw:name="frame"
text:anchor­type="as­char" svg:width="1.905cm" svg:height="2.536cm"
draw:z­index="0">
<draw:image
xlink:href="Pictures/46A4419C2D.jpg"
xlink:type="simple" xlink:show="embed" xlink:actuate="onLoad"/>
</draw:frame>
</text:p>
Struttura di una immagine in XML
L'immagine viene inserita dentro un blocco di testo, all'interno dell'elemento draw:frame in cui sono dichiarati l'ancoraggio, l'allineamento rispetto alla pagina, la dimensione, gli altri effetti di presentazione sono definiti, in questo esempio, nello stile “fr1”, mentre il nodo draw:image definisce principalmente quale immagine deve essere importata nel documento. Le immagini contenute nel documento sono inserite nel documento stesso, dentro alla cartella Pictures; perciò il file ODT può essere utilizzato anche su piattaforme che non contengono le immagini che sono inserite all'interno del documento, inoltre, 46
proprio perchè sono contenute all'interno del file, è possibile ricavarle facilmente.
In XSL­FO questa immagine viene così rappresentata:
<fo:block>
<fo:external­graphic src="Pictures/46A4419C2D.jpg"
scaling="non­uniform" content­width="1.905cm" content­height="2.536cm"
display­align="center" border="0.018cm solid #000000" text­align="start"
margin­left="0cm" margin­right="0cm"/>
</fo:block>
Rappresentazione di una immagine in XSL­FO
La figura viene inserita nel nodo fo:external­graphic. In questo elemento sono dichiarati l'immagine che deve essere inserita e il suo stile.
Purtroppo in XSL­FO non viene gestito l'ancoraggio, infatti mentre nell'ODT è possibile scegliere se ancorare un immagine alla pagina, al paragrafo o al carattere, questo nel documento FO non può essere fatto.
3.2.5 Intestazioni e piè di pagina
Le definizioni delle intestazioni, dei piè di pagina e dei loro stili sono contenuti all'interno del file styles.xml.
Gli stili, ad esempio la larghezza e l'allineamento, sono inseriti nella definizione del modello di pagina, mentre il contenuto degli header o dei footer è all'interno del nodo office:master­styles.
Un esempio di un piè di pagina può essere il seguente:
47
<....>
<style:page­layout style:name="pm1">
<style:page­layout­properties .... >
<style:footnote­sep style:width="0.018cm" style:distance­before­sep="0.101cm"
style:distance­after­sep="0.101cm" style:adjustment="left"
style:rel­width="25%" style:color="#000000"/>
</style:page­layout­properties>
<style:header­style/>
<style:footer­style>
<style:header­footer­properties fo:min­height="1.251cm" fo:margin­top="1.152cm"style:dynamic­spacing="true"/>
</style:footer­style>
</style:page­layout>
<....>
<style:master­page style:name="Standard" style:page­layout­name="pm1">
<style:footer>
<text:p text:style­name="Footer">
<text:span text:style­name="Page_20_Number">
<text:page­number text:select­page="current"> 7
</text:page­number>
</text:span>
</text:p>
</style:footer>
</style:master­page>
Struttura di un footer in XML
Nel documento XSL­FO l'intestazione e il piè di pagina sono inseriti direttamente nel fo:page­seguence, nella regione riservata ad essi. Infatti quando viene definita una pagina si assegna un nome alla regione che sarà occupata dall'header e quella occupata dal footer.
Quando questi elementi sono presenti nel documento ODT, è sufficiente aggiungere il nodo fo:static­content, avente come flow­
48
name il nome della regione a cui si riferisce, e inserire al suo interno il contenuto.
Questo viene illustrato dal seguente codice:
<...>
<fo:page­sequence master­reference="Standard">
<fo:static­content flow­name="Standard­after">
<fo:block white­space­treatment="preserve" line­height="normal"
font­family="Times New Roman, serif" font­size="12pt"
language="it" country="IT" hyphenate="false" hyphenation­push­character­count="2"
hyphenation­remain­character­count="2"
hyphenation­ladder­count="no­limit">
<fo:inline>
<fo:page­number/>
</fo:inline>
</fo:block>
</fo:static­content>
<fo:flow flow­name="xsl­region­body">
<....>
</fo:flow>
</fo:page­sequence>
Footer in XSL­FO
3.2.6 Footnotes
Alcuni documenti ODT possono contenere all'interno delle note a piè di pagina. Queste compaiono all'interno del file content.xml, poiché di solito sono associate al testo in esso contenuto. Un esempio di come viene rappresentata una nota a piè di pagina è:
49
<text:p text:style­name="Standard">
Nota a piè di pagina
<text:note text:id="ftn0" text:note­class="footnote">
<text:note­citation>1</text:note­citation>
<text:note­body>
<text:p text:style­name="Footnote">
Nota a piè di pagina1
</text:p>
</text:note­body>
</text:note>
</text:p>
Struttura di una nota a piè di pagina in XML
Ogni volta che nel testo viene definita una nota a piè di pagina, questa viene inserita nel blocco di testo a cui si riferisce.
La rappresentazione di questa struttura in XSL­FO è simile: <fo:block ....>Nota a piè di pagina
<fo:footnote>
<fo:inline font­size="0.83em" baseline­shift="super">1</fo:inline>
<fo:footnote­body>
<fo:list­block provisional­distance­between­starts="20pt"
provisional­label­separation="5pt">
<fo:list­item>
<fo:list­item­label end­indent="label­end()">
<fo:block font­size="0.83em" line­height="0.9em">1</fo:block>
</fo:list­item­label>
<fo:list­item­body start­indent="body­start()">
<fo:block font­size="0.83em" line­height="0.9em">
<fo:block ...>
Nota a piè di pagina1
</fo:block>
</fo:block>
</fo:list­item­body>
</fo:list­item>
</fo:list­block>
</fo:footnote­body>
</fo:footnote>
</fo:block>
Struttura di una nota a piè di pagina in XSL­FO
50
Per ogni footnote viene inserito l'elemento fo:footnote che contiene il simbolo da utilizzare nella nota (che viene poi ripetuto in fo:list­item­label) e il suo contenuto.
3.3 Problemi dell'approccio in XSL-FO
Il linguaggio XSL­FO e il processore utilizzato in questo progetto pongono a volte delle limitazioni nell'implementazione della trasformazione da ODT a PDF. Infatti XSL­FO e il suo processore non sempre supportano alcuni elementi che possono essere presenti nel documento di testo.
3.3.1 Ancoraggio delle immagini
In un documento ODT è possibile specificare l'ancoraggio delle immagini, ad esempio una figura può essere ancorata alla pagina, al paragrafo o al carattere. Questa informazione, durante la conversione nel formato XSL­FO, viene persa perché il linguaggio XSL­FO non supporta l'ancoraggio.
51
3.3.2 Divisione di una pagina in colonne
E' possibile dividere la pagina di un documento di testo in colonne. In ODT si può specificare la larghezza delle singole colonne. Questo in XSL­FO non è possibile farlo poiché nelle recommendation del linguaggio è possibile dividere il corpo della pagina in colonne, ma la dimensione delle colonne viene ricavata automaticamente attraverso il seguente calcolo. column­in­size = (body­in­size ­ (N ­ 1)*column­gap)/N
Dove body­in­size è la dimensione del corpo della pagina, N è il numero di colonne che si vogliono ottenere, e column­gap è lo spazio che deve essere presente tra le colonne.
3.3.3 Allineamento Tabelle
Nel documento ODT è possibile specificare l'allineamento della tabella, è possibile inserire una tabella al centro, a sinistra o a destra. Purtroppo il linguaggio XSL­FO non prevede che si possa specificare tale allineamento, che viene settato a sinistra di default.
3.3.4 Posizionamento delle immagini
Il posizionamento delle immagini, stabilito nel documento ODT, non è mantenuto nel file in output PDF. Infatti alcune immagini 52
vengono sovrapposte dal testo, nonostante la loro dichiarazione nel file XSL­FO sia corretta. Si pensa quindi ad un bug all'interno di FOP. Si è anche provato ad utilizzare versioni di FOP ancora in via di sviuppo, ma non sono stati ottenuti miglioramenti.
3.3.5 Tabelle
Altri errori di rappresentazione si presentano con la gestione delle tabelle: il testo in esse contenuto non rispetta l'allineamento verticale. Nel documento ODT è possibile definire che il testo, contenuto in una tabella, sia allineato in alto, in basso o al centro. Nel linguaggio XSL­FO questo tipo di allineamento è previsto ed è indicato dall'attributo “vertical­align”, tuttavia questo viene ignorato dal processore fo, e il testo della tabella viene sempre allineato in alto.
3.4 Conversione di ODT in PDF
Verranno ora illustrate le immagini della trasformazione da un documento ODT ad uno PDF.
Il primo documento che viene mostrato contiene al suo interno del testo, un'immagine, un'intestazione, un piè di pagina contenente il 53
numero della pagina.
Mentre il secondo file contiene anch'esso del testo e il footer. Come si potrà vedere ci sono dei problemi nella trasformazione, infatti il piè di pagina risulterà incompleto. Questo problema di visualizzazione sarà trattato nel prossimo capitolo.
54
Illustrazione 8: Documento 1 in formato ODT
55
Illustrazione 9: Documento 1 in formato PDF
56
Illustrazione 10: Documento 2 in formato ODT
57
Illustrazione 11: Documento 2 in formato PDF
58
4 ARCHITETTURA
O2PX
DEL
CONVERTITORE
In questo capitolo verrà analizzato il foglio di stile XSLT che consente di effettuare la trasformazione dal formato ODT a quello XSL­FO e verrà illustrato il programma Java con le relative classi di cui è composto. 4.1 Sviluppo del progetto
L'applicazione, che è stata realizzata per effettuare la conversione, viene richiamata da linea di comando e le vengono passati come parametri il documento da trasformare, il nome del file PDF, che deve essere creato, con la relativa destinazione, e il file FO che deriva dalla prima trasformazione.
L'applicazione è scritta in Java, tecnologia realizzata dalla Sun Microsystems. E' un linguaggio di programmazione orientato agli oggetti, indipendente dalla piattaforma sulla quale è utilizzato e contenente strumenti e librerie per il networking. Java è un linguaggio sia interpretato che compilato. Il programma scritto in Java viene tradotto, attraverso un compilatore, in un formato intermedio chiamato bytecode, il quale viene passato 59
all'interprete, Java Virtual Machine, che si occupa di tradurre in real­time l'applicazione in linguaggio comprensibile dall'elaboratore. La fase di compilazione viene svolta una sola volta, mentre l'interpretazione avviene ogni volta che viene eseguito il programma.
E' sufficiente che ogni piattaforma abbia a disposizione la propria macchina virtuale Java per poter eseguire il programma su ogni sistema operativo. Questo quindi premette di creare applicazioni che possano funzionare su molti sistemi diversi.
Inoltre l'interprete Java si trova nei browser più comuni (ad esempio Internet Explorer o Mozilla), quindi, indipendentemente dal tipo di computer che si sta usando, basta usare uno di questi browser per poter eseguire il programma. Questo ha portato Java ad avere un grande successo nel campo delle applicazioni web. Si è scelto di scrivere il progetto di tesi in Java per le caratteristiche che sono state appena analizzate.
Il programma si occupa di prendere in input il file ODT; da questo vengono estratti il content.xml e lo styles.xml, che, come è stato già detto, contengono il testo e le informazioni di stile appartenenti al documento. Viene creato un documento XML, nel quale vengono inseriti i file del contenuto e dello stile del documento, e a questo nuovo documento viene applicato il foglio di stile XSLT, che lo analizza e ne trasforma la struttura restituendo il file in formato XSL­FO, che racchiude il contenuto dell'ODT al quale sono associati gli aspetti presentazionali e di formattazione. Il documento XSL­FO viene passato ad un processore FO che 60
restituisce in output il file in formato PDF. Successivamente saranno analizzati nel dettaglio la tecnologia XSLT e la struttura del progetto.
L'applicazione realizzata, anche grazie al linguaggio con cui si è scelto di implementarla, è indipendente dalla piattaforma sulla quale viene utilizzata, quindi non si è vincolati ad utilizzare un determinato sistema operativo poiché può girare su tutti i tipi di computer, l'unico requisito è che sul computer sia installata la Java Virtual Machine; è facilmente portabile sul web, quindi si può utilizzare questo servizio anche da remoto, usufruendo così della comodità che questo comporta; è stand­alone, cioè non ha bisogno di interfacciarsi con altri programmi, evitando così che si verifichi uno spreco di risorse, infatti si chiama direttamente l'applicazione.
Analizzando il progetto a basso livello, lo si può suddividere in quattro componenti principali: l'applicazione Java, il foglio di stile XSLT, e come è stato già visto, il linguaggio XSL­FO, ed il processore FO.
Per questo progetto si è scelto di utilizzare l'XSLT (eXtensible Stylesheet Language Transformations), un linguaggio che consente la trasformazione di documenti XML (eXtensible Markup Language) in altri documenti XML, derivato da XSL, scritto con una sintassi XML (elementi, attributi, struttura ad albero, namespace), divenuto uno standard web con una direttiva (Recommendation) W3C [W3C99].
61
4.1.1 XSLT
La funzione di un documento XSLT è quella di manipolare e trasformare un documento XML in un altro documento XML, con una sintassi diversa ma il medesimo contenuto, ad esempio un documento HTML, XHTML, RTF, o un altro formato di solo di testo.
Per generare una trasformazione in XSLT servono due file: il documento da trasformare, che deve essere in XML ben formato, e il foglio di stile XSLT, che definisce la semantica per la trasformazione.
Il foglio di stile vede il documento XML come una serie di nodi strutturati ad albero. E' formato da una serie di modelli, chiamati “template”, che contengono le regole di trasformazione da applicare ai nodi del documento XML. Nella sintassi XSLT, i “template” sono elementi, a ciascuno dei quali corrisponde l'attributo “match”, associato al nodo che deve essere trasformato. Nel documento che viene generato è possibile inserire elementi completamente nuovi, non prendere in considerazione, e quindi non riportare, elementi già esistenti nel documento XML d'origine, riordinare gli elementi, fare elaborazioni in base al risultato di determinate condizioni, modificare nodi esistenti aggiungendo, ad esempio degli attributi, e altro ancora. La trasformazione avviene tramite un apposito programma, il processore XSLT, che riceve in input il documento XML, del quale prende il contenuto, e il foglio di stile dal quale ricava la struttura e le regole di presentazione, generando il documento risultante, XML , nel formato specificato 62
dalle regole.
Il processore XSLT segue la struttura gerarchica del documento di partenza: individua ciascun nodo grazie alle istruzioni contenute nel foglio di stile, che esegue ricorsivamente, nodo per nodo. Quando il processore trova una corrispondenza (matching), al contenuto dell'elemento analizzato vengono applicate le regole del template contenuto nell'XSLT [WIK06]. Nel progetto viene utilizzato un processore scritto in Java, applicazione che verrà illustrata più avanti. Dall'elaborazione del foglio di stile XSLT, in base alle regole in esso specificate, si ottiene in output un documento in formato XSL­FO (XSL Formatting Object). 4.2 Il processore Java
Il programma Java è costituito da due pacchetti:
–
main: contiene al suo interno la classe main. Questo prende in input il file ODT da convertire e il nome, con la relativa destinazione, del documento PDF da generare, e si occupa di richiamare le varie funzioni della libreria Java per poter così effettuare la trasformazione;
–
63
odt2pdf: contiene le classi
ODTFOConverter e FOPDFConverter. Queste due definiscono le funzioni per poter effettuare la trasformazione del formato.
Nella classe ODTFOConverter viene definito il metodo per decomprimere il documento ODT, che viene passato in input e sul quale dovrà poi essere eseguita la trasformazione. Si ottengono così i file content.xml e styles.xml, che contengono il contenuto e gli aspetti presentazionali del documento di testo. Viene quindi creato un oggetto DOM (Document Object Model), che ha come nodo principale l'elemento definito “radice”. All'interno di questo nuovo oggetto vengono inseriti l'albero dei nodi del file content.xml e quello del file styles.xml. Al DOM risultante viene quindi applicato un foglio di stile XSLT che lo converte in un documento XSL­FO. Il processore XSLT utilizzato per eseguire questa trasformazione è SAXON 6.5.5.
Nella classe FOPDFConverter viene definito il metodo che consente la trasformazione da formato XSL­FO a PDF, effettuata attraverso un processore FO, il quale mette a disposizione delle API. Utilizzando questi metodi si riesce ad avere in output il file PDF che si voleva ottenere.
Nel progetto Java, per integrare il processore FO, sono state importate tutte le librerie del processore Apache FOP, e sono poi stati richiamati i relativi metodi.
64
4.3 Documento XSLT
Come detto precedentemente la libreria Java definisce il processore XSLT, il quale applica il foglio di stile XSLT, chiamato foglioxslt.xsl, al documento xml che viene creato. Il file foglioxslt.xsl esamina il contenuto del documento xml. In primo luogo verifica se è presente, in quest'ultimo, il nodo definito “radice”. Tale nodo è molto importante, perché se per qualche motivo questo non è presente, il processore termina la sua esecuzione e restituisce un documento vuoto. Una volta che la radice è stata analizzata, viene definita la struttura del foglio XSL­FO. Viene definito il nodo iniziale di tale file, il nodo “fo:root”, il quale conterrà al suo interno la definizione degli stili delle pagine, la definizione delle intestazioni e dei piè di pagina e la definizione delle pagine con il loro contenuto. 4.3.1 Definizione degli stili di pagina
Si devono inserire le definizioni degli stili di pagina contenute nel codice relativo al file styles.xml. Per cominciare si inserisce l'elemento “fo:layout­master­set”, al cui interno vengono inserite tutte le dichiarazioni degli stili di pagina. Poi, per ogni stile di pagina,
viene
creato
un
elemento
chiamato “fo:simple­page­master”, che contiene tutte le informazioni sullo 65
stile della pagina, quali il nome del formato della pagina o la sua altezza e larghezza, e vengono inoltre definiti i margini, quello superiore e inferiore e quello destro e sinistro, ed il modo di scrittura, dall'alto verso il basso o da sinistra verso destra. Oltre alle informazioni riguardanti la pagina vengono inserite anche le informazioni relative al corpo della pagina, chiamato body; queste vengono inserite nell'elemento “fo:body”. Al suo interno vengono inseriti i margini superiori e quelli inferiori che possono cambiare nel caso siano presenti o meno l'intestazione o il piè di pagina. Il corpo del documento, inoltre, può essere diviso in colonne, nel qual caso vengono inseriti gli attributi “column­count” e “column­gap”, che rappresentano il numero delle colonne in cui è diviso il corpo del documento e la distanza tra loro; tutte le colonne hanno la stessa larghezza. Nel caso in cui le colonne del documento differiscano in larghezza, come è stato già anticipato, non è possibile rappresentarle correttamente.
Una volta definito lo stile delle pagine, si passa a dichiarare il suo contenuto: se è stato dichiarato un solo stile di pagina si inserisce subito l'elemento “fo:page­sequence” in cui vengono poi inseriti il corpo del documento, l'intestazione e il piè di pagina, se presenti; invece, se sono stati dichiarati più stili di pagina si cerca quale sia lo stile della prima pagina da inserire.
Bisogna sapere, a tal proposito, che, nel caso in cui siano presenti più stili di pagina, l'informazione relativa a quale stile è utilizzato si trova tra le proprietà del primo paragrafo o della prima tabella del testo, ed è indicato dall'attributo “style:master­page­name”. 66
Perciò si deve trovare il nodo che abbia questo attributo, e una volta ottenuto il nome dello stile della prima pagina, si analizza la definizione di tale stile.
Nel caso vengano dichiarati più stili di pagina si possono avere due gestioni diverse dell'applicazione degli stili. Gli stili possono essere associati alle pagine in due modi diversi: –
nel primo caso il modello della pagina è associato al paragrafo, ed ogni volta che viene cambiato lo stile della pagina viene usato uno modello di paragrafo nella cui definizione è contenuto style:master­page­name che specifica quale stile di pagina deve essere usato. Nel foglio XSL­FO ogni volta che viene cambiato il modello da applicare alla pagina verrà inserita una “fo:page­sequence”, nella quale verranno inseriti l'intestazione, il piè di pagina e il contenuto della pagina in questione.
–
altrimenti nel secondo all'interno della definizione dello stile della prima pagina sarà presente l'attributo “style:next­style­name”. In questo caso lo stile che stiamo analizzando sarà applicato solo ad una pagina, dopo la quale sarà applicato lo stile richiamato dall'attributo. Per poter realizzare ciò nel documento XSL­FO è necessario inserire all'interno
del
“fo:layout­master­set”,
il
nodo “fo:page­sequence­master” nel quale sarà definita la struttura del documento, ovvero si specificherà in che sequenza devono comparire gli stili delle pagine. A tale elemento verrà assegnato un nome e al suo interno saranno inseriti nodi “fo:repeatable­page­master­reference” che 67
conterranno l'attributo “maximum­repeats” impostato ad uno se la pagina è presente solo una volta, se tale attributo non è presente significa che questo stile sarà applicato ripetutamente alle varie pagine. Dopo aver definito la struttura del documento, al di fuori del “fo:layout­master­set”, si inserisce il “fo:page­sequence” in cui verrà richiamata la struttura dichiarata nel “fo:page­
sequence­master”. 4.3.2 Definizione dell'intestazione e del piè di pagina
I documenti ODT possono contenere le intestazioni e i piè di pagina, che non necessariamente devono comparire contemporaneamente. La dichiarazione di questi elementi è presente nel file styles.xml.
Nel momento in cui viene inserita una “fo:page­sequence”, viene analizzato se tale pagina contiene l'intestazione e il piè di pagina. Ognuno di questi elementi è gestito da una funzione, in cui viene inserito un “fo:static­content” con “flow­name” uguale e “xsl­region­before” se si riferisce all'intestazione e “xsl­region­after” se è riferito al piè di pagina. Nel documento ODT la dimensione delle intestazione e dei piè di pagina viene ricavata automaticamente. Nel file styles.xml è presente l'attributo “fo:min­height”, che rappresenta l'altezza minima che deve avere l'elemento, ma non viene fornita l'altezza effettiva dell'area.
68
All'interno del “fo:static­content” vengono inseriti il margine inferiore o superiore a seconda di quale elemento si stia trattando, l'altezza minima dell'area occupata da tale elemento, ottenuta dall'attributo nominato prima, e il contenuto dell'elemento; ma poiché non è possibile calcolare e ottenere l'altezza effettiva delle aree dell'intestazione e del piè di pagina, si incontrano problemi di rappresentazione quando queste aree superano la dimensione dell'altezza minima.
4.3.3 Definizione dei paragrafi di testo
Il contenuto di un documento ODT è costituito principalmente da testo, strutturato in paragrafi, ognuno dei quali viene identificato dal nodo “text:p” seguito dal nome dello stile che viene applicato al testo.
Lo stile dei paragrafi è strutturato ad albero. Lo stile associato al nodo paragrafo inserito nel testo è la foglia di questa struttura, quindi per ottenere tutte le informazioni sullo stile da applicare bisogna risalire quest'albero. Si conosce lo stile del nodo, e si deve quindi risalire allo stile del testo, allo stile del nodo padre, fino alla radice costituita dallo stile della famiglia. La definizione dello stile presente all'interno del nodo text:p può essere contenuta nel file content.xml o nel file styles.xml, a seconda dei casi. La dichiarazione dello stile del nodo è presente all'interno del file content.xml, se è una personalizzazione dello stile del testo e 69
questo è contenuto nel file content.xml, altrimenti, nel caso del contenuto dell'intestazione o del piè di pagina, la personalizzazione dello stile è presente nel file styles.xml. Per personalizzazione di uno stile si intende ad esempio la modifica del carattere, della dimensione, dell'allineamento del testo.
L'attributo “style:parent­style­name”, che abbiamo chiamato stile del testo, indica lo stile dal quale eredita le varie proprietà e le modifica. Altrimenti, se lo stile non viene personalizzato, la definizione dello stile del nodo compare nel file styles.xml e coincide con lo stile del testo, il quale definisce le proprietà per i paragrafi e per il testo; anche questo nodo possiede l'attributo “style:parent­style­name” che indica il nome dello stile del nodo padre, ossia il nodo dal quale eredita le varie proprietà che poi possono essere modificate, e l'attributo “style:family”, il quale indica il nome dello stile della famiglia. Lo stile del nodo padre è definito all'interno di styles.xml e definisce le varie proprietà per i paragrafi e per il testo.
Si arriva, infine, ad analizzare lo stile della famiglia. Di solito tutti gli stili del testo discendono dalla famiglia “paragraph”, la definizione di questo stile è presente nel file styles.xml, all'interno del nodo “style:default­style”; anch'esso definisce le proprietà del paragrafo e le proprietà del testo.
Nel documento XSL­.FO il testo viene inserito nell'elemento “fo:block”, al suo interno vengono inseriti gli attributi ricavati dagli stili presenti nel documento xml. Per ogni attributo si analizza lo stile del nodo: se questo non compare si analizza lo stile del testo, e nel caso in cui non venga trovato nemmeno in questa posizione 70
viene esaminato lo stile del nodo padre, fino ad arrivare allo stile della famiglia. Per quanto riguarda lo stile del nodo si deve tenere in considerazione la posizione del testo, se cioè questo si trovi nel corpo del documento, o nell'intestazione, o ancora nel piè di pagina, perché può succedere, ad esempio, che in entrambi i documenti styles.xml e content.xml compaia lo stile “P1”. Per evitare una ricerca sbagliata delle proprietà del testo, l'analisi dovrà essere effettuata nel documento in cui il testo stesso è contenuto.
4.3.4 Definizione delle tabelle
Un documento può essere caratterizzato dalla presenza di tabelle. Ogni tabella ha un nome ed uno stile, che vengono identificati da “table:name” e da “table:style­name”. La definizione dello stile è presente all'interno del documento content.xml se la tabella compare nel corpo del documento, altrimenti è nello styles.xml poiché compare nell'intestazione o nel piè di pagina.
Nella definizione dello stile della tabella vengono definiti i margini e la larghezza di essa. Questi attributi vengono inseriti nel nodo “fo:table”, che contiene al suo interno la dichiarazione delle colonne e delle righe. Per ogni colonna viene inserito l'elemento “fo:table­column”, che contiene il nome dello stile applicato, il numero e la larghezza della colonna. Alcune tabelle presentano anche delle righe di intestazione, le quali vengono inserite 71
nell'elemento “fo:table­header”, e vengono analizzate insieme al loro contenuto. Vengono infine analizzate le righe, inserite nel corpo della tabelle, le quali sono caratterizzate da un proprio stile, che ne determina l'altezza, e sono divise in celle. Ognuna di esse contiene il numero di colonna a cui si riferisce, e le informazioni di stile, come il colore di sfondo, i bordi, l'allineamento del testo.
Il foglioxslt.xsl gestisce anche l'unione delle celle.
4.3.5 Definizione delle immagini e delle cornici
Alcuni documenti contengono al loro interno immagini, che sono salvate all'interno del file odt nella directory Pictures, per cui se si dovesse aver bisogno di recuperare l'immagine originale, è sufficiente estrarla dall'archivio.
Nel documento xml le immagini sono identificate dal nodo “draw:frame”, che identifica anche le cornici delle immagini e le cornici di testo. I nodi “draw:frame” che contengono le immagini sono identificati dal nodo figlio “draw:image”, il quale contiene al suo interno il nome dell'immagine e tutte le sue proprietà.
La cornice dell'immagine, come detto precedentemente, è contenuta nel nodo “draw:frame”, il quale racchiude un altro nodo "draw:frame", che contiene l'immagine. Di cornici del testo, invece, esistono due tipologie: una è caratterizzata dal nodo “draw:frame”, mentre l'altra utilizza l'elemento “draw:text­box”. Entrambi questi nodi racchiudono al loro interno il testo che dovrà essere analizzato. 72
4.3.6 Definizione degli elenchi puntati
Viene gestita anche la presenza degli elenchi, definiti anche liste, che possono essere numerati o puntati.
Ogni elenco ha un proprio stile che deve essere analizzato per poter definire correttamente ogni oggetto. Nella definizione dello stile viene specificato il modello di numerazione o di punti da utilizzare ad ogni livello. Infatti una lista può essere strutturata su più livelli: succede quando un elemento contiene a sua volta un elenco, e questo può essere avvenire ricorsivamente. Nella definizione dello stile di un elenco è previsto un modello di numerazione e di punti diverso per ogni livello. Quindi, quando si inserisce il blocco per la lista, si deve tenere in considerazione lo stile da applicare all'elenco e il livello in cui si trova il nodo, e, nel caso in cui il nodo contenga al suo interno un'altra lista, si applica ricorsivamente il “template” dell'elenco.
Il prefisso degli elenchi numerati deve essere costruito utilizzando il prefisso, il tipo di numerazione, poiché potrebbe essere costituito da numeri arabi, numeri romani o lettere, e il suffisso, mentre per gli elenchi puntati è sufficiente prendere il modello di punto o “bullet” da utilizzare.
73
4.4 Problemi e bug
L'esecuzione di questo progetto non è perfetta, poiché il documento PDF che viene restituito non sempre è conforme al documento ODT di partenza. Sono stati precedentemente esaminati i problemi causati dall'approccio con XSL­FO e processori FO. Qui di seguito saranno illustrati i problemi causati dall'implementazione e dall'utilizzo della tecnologia XSLT.
4.4.1 Tabelle
Può succedere che una tabella abbia un margine sinistro maggiore di 0, ed in questo caso si presenta un ulteriore problema, perché quando si ha questo rientro il testo della tabella compare con una rientranza maggiore e questo causa che il testo, se lungo, esca dalla tabella, quando questa non è molto larga, o in alcuni casi esca dalla pagina. Il testo non va a capo poiché l'algoritmo di costruzione delle righe non riconosce che la tabella, e quindi anche la pagina, sono finite. Questo succede perché l'algoritmo considera, giustamente, di riempire lo spazio della tabella che può essere occupato dal testo, ma poiché il testo compare con una ulteriore rientranza a destra, lo spazio della tabella che può essere riempito è inferiore.
74
4.4.2 Intestazioni e piè di pagina
Si incontrano alcune problematiche anche nella gestione delle intestazioni e dei piè di pagina, come precedentemente anticipato.
Infatti nel documento ODT non viene specificata l'altezza dell'intestazione e del piè di pagina, viene solo fornita un'altezza minima. Nel foglio XSL­FO, ricavato dall'applicazione del foglio di stile XSLT, l'altezza minima viene sì inserita, ma questo non comporta nessun significativo cambiamento, poiché l'area dell'intestazione e quella del piè di pagina rimangono invariate. Pertanto se l'header o il footer superano la dimensione dell'altezza minima vengono sovrapposti al testo del corpo del documento. Una soluzione a questo problema è quella di stabilire per tali aree un'altezza fissa, impostandola abbastanza grande da non avere problemi di sovrapposizione con il testo, tuttavia così facendo non vengono risolti completamente i problemi, perché questi si ripresentano sotto due forme. Se le intestazioni o i piè di pagina, a seconda di ciò che si sta trattando, fossero più piccole dell'area riservata ad esse si avrebbe uno spreco di spazio, poiché tra questo oggetto e il corpo del testo si presenterebbe un certo spazio, che rimarrebbe vuoto. Anche in questo caso il documento PDF risulterebbe diverso dal file ODT. Se, invece, le intestazioni o i piè di pagina fossero più grandi della zona riservata ad essi si ripresenterebbe di nuovo il problema della sovrapposizione.
Pertanto si è deciso di lasciare impostata l'altezza di tali aree a quella minima presente nel documento ODT.
La soluzione ottimale per risolvere questo problema sarebbe quella 75
di trovare l'algoritmo utilizzato da ODT e codificarlo nell'XSLT per calcolare la dimensione giusta.
4.4.3 Metadati
XSL­FO non permette di impostare i metadati presenti nel documento ODT, come ad esempio l'autore, il titolo, l'ultima modifica. Esistono dei processori FO, ad esempio XF Rendering Server 2008, che mettono a disposizione una sintassi per inserire queste informazioni nel documento PDF che viene restituito, ma questo diminuisce la flessibilità del convertitore, in quanto si è poi obbligati ad utilizzare quel determinato processore FO. 4.4.4 Allineamento del testo dei paragrafi
Si è notato che quando un documento ODT viene convertito in PDF, la prima riga del paragrafo viene spostata più a sinistra rispetto alle righe sucessive facenti parte dello stesso paragrafo.
Il documento in formato XSL­FO è costruito correttamente, e non è inserito nessun attributo che possa giustificare questa discrepanza nella visualizzazione. Pertanto si pensa che ci sia qualche problema nel processore FOP.
4.4.5 Font Family
Il documento PDF che si ottiene in output a volte può presentare 76
font diversi da quelli specificati nel ODT, nonostante nel file XSL­FO venga inserito il font utilizzato nel documento di testo. Si ha quindi un problema durante la trasformazione da XSL­FO a PDF, sembra che FOP ignori i font­family specificati. Infatti FOP supporta solo parzialmente i font dei caratteri.
4.4.6 Float
Nelle recommendation di XSL­FO esiste l'elemento fo:float al cui interno possono essere inserite le immagini. Questo elemento consente una gestione migliore delle immagini, ma non la versione 0.94 di FOP non gestisce tale nodo.
4.4.7 Campi dinamici
In ODT è possibile specificare dei campi dinamici, un esempio potrebbe essere rappresentato dalla data corrente, in un documento infatti potrebbe essere inserito un campo che mostri automaticamente la data corrente, questo eviterebbe di dover modificare il documento.
Purtoppo questo non è possibile implementarlo a causa di un limite dovuto alla tecnologia utilizzata , infatti è impossibile da fare in XSLT. 77
78
5 CONCLUSIONI
L'obiettivo di questo progetto è la realizzazione di un programma che effettui la trasformazione di un documento dal formato ODT al formato PDF, passando per il formato intermedio XSL­FO.
Questo programma doveva essere uno strumento portabile e stand­alone. Questa tesi ha dimostrato che l'applicazione realizzata rispetta gli obiettivi inizialmente posti, e i test condotti ne hanno confermato il corretto funzionamento. E' stato osservato che tale applicazione è indipendente dalla piattaforma utilizzata, e che quindi può essere usata su tutti i sistemi operativi, nonché su web. Inoltre non causa sprechi di risorse, in quanto non necessita di appoggiarsi ad alcun programma esterno per essere eseguito (come ad esempio OpenOffice.org). I documenti generati dal convertitore sono di ottima qualità, e le loro dimensioni contenute. Si è osservato, infatti, che i PDF ottenuti a volte sono di dimensione inferiore rispetto a quelli creati da altri programmi (come OpenOffice.org) e sono più piccoli dei documenti originali ODT, cosa che gli altri programmi non sempre garantiscono. Ad esempio un documento ODT di dimensione ~40KB, con l'esportazione in PDF di OpenOffice.org diventa ~218KB, mentre il PDF risultante dalla conversione di O2PX è ~35KB.
Nello stato attuale del progetto sicuramente possono essere 79
apportate modifiche e migliorie. Come è stato detto, la trasformazione avviene attraverso un formato intermedio, XSL­FO. Il documento FO può essere convertito in altri formati, quindi si potrebbe modificare il programma in modo che nel secondo passaggio di trasformazione, possa essere offerta la scelta del formato di output che si vuole ottenere. Il progetto presenta alcuni problemi di rappresentazione che causano una serie di differenze tra il documento originale e quello che viene ricavato, pertanto in futuro dovrà essere posta attenzione alla risoluzione di questi bug, che dipendono direttamente anche dallo sviluppo dei software correlati. Una nuova versione di Apache FOP che implementi correttamente tutte le funzioni previste nella recommendation W3C ne risolverebbe alcuni. Oppure si potrebbe intervenire manualmente sia sul documento XSLT, trovando delle soluzioni che aggirino i problemi di visualizzazione, sia sul codice di Apache FOP, migliorandone le lacune ed aggiungendovi alcune funzionalità.
Un'ulteriore miglioria che sicuramente potrebbe essere apportata all'applicazione Java è la creazione di una interfaccia grafica che consenta di scegliere il documento ODT che deve essere trasformato. Al momento infatti, il programma viene richiamato da riga di comando, digitando come parametro il documento da trasformare. Quindi la creazione di un'interfaccia renderebbe più facile e intuitiva la ricerca del file da convertire e il percorso in cui inserire il documento PDF appena creato.
Inoltre si è detto che il formato PDF offre la possibilità di proteggere il proprio lavoro inserendo password e autorizzazioni 80
speciali per controllare chi può aprire, visualizzare, modificare e stampare un documento PDF. È inoltre possibile apporre firme digitali che possono essere autenticate. PDF mette a disposizione due tipi di password: la password del proprietario e la user password. La password del proprietario controlla le opzioni di sicurezza (o permessi), ma non impedisce a un file di essere caricato e visto, e questo lo rende vulnerabile. La user password impedisce a un file di essere decifrato e visto. Un'aggiunta interessante potrebbe essere quella di consentire la protezione di un documento PDF. Questo permetterebbe di condividere i dati sensibili in modo sicuro e riservato.
Apache FOP mette a disposizione questa funzionalità. Infatti permette di impostare una owner password, che viene utilizzata come chiave di codifica, o una user password, questa farà in modo che il programma di visualizzazione del PDF chieda al lettore questa password per poter visualizzare il contenuto del documento. Ulteriori restrizioni possono essere imposte con le opzioni ­noprint, ­nocopy, ­noedit e ­noannotations, che disabilitano rispettivamente la stampa, la copia del testo, la modifica e le annotazioni.
Inoltre la quasi totalità dei programmi che effettuano la conversione da un documento ODT, producono in output un unico file PDF composto da più pagine. Ci sono programmi che consentono di dividere un documento in più file, uno per pagina, un esempio di questi programmi è rappresentato da pdftk [ACC04]. Sarebbe quindi interessante poter aggiungere anche questa caratteristica al progetto, offrendo la possibilità di scegliere 81
se ottenere dalla conversione del documento ODT un unico file PDF o file differenti per ogni pagina del documento originale.
L'ultima modifica che potrebbe essere apportata al progetto è la possibilità di modificare il layout di una pagina. Si potrebbero mettere a disposizione più modelli di pagina che possiedono stili diversi, ad esempio potrebbero essere definiti a priori le dimensioni della pagina, il font per il titolo e quello per il corpo del documento. Attraverso un'interfaccia grafica potrebbe essere possibile scegliere il modello da applicare, si potrebbe scegliere di ottenere in output un file con lo stesso layout del documento di partenza o di stravolgerne l'aspetto adottando il template di uno dei modelli proposti. In questo caso tutti gli altri aspetti presentazionali sarebbero modificati, gli unici a rimanere invariati sarebbero il testo e gli aspetti editoriali, come tabulazioni, andate a capo, sottolineatura, corsivo o grassetto di alcuni termini.
82
Bibliografia
[ACC04] AccessPDF, pdftk, 2004, http://www.accesspdf.com/pdftk/
[ACT07] activePDF, activePDF, 2007, http://www.activepdf.com/
[ACT08] activePDF, PrimoPDF v3.2, 2008, http://www.primopdf.com/
[ADO06] Adobe, PDF Reference – Adobe Portable Document Format
version 1.7, 29 Ottobre 2007,
http://www.adobe.com/devnet/acrobat/pdfs/pdf_reference_1-7.pdf
[ADO08a] Adobe, Adobe Portable Document Format,
http://www.adobe.com/it/products/acrobat/adobepdf.html
2008,
[APA07] Apache, Apache FOP, 2007, 18 Novembre 2007,
http://xmlgraphics.apache.org/fop/
[CUP07a] CUPS-PDF, CUPS-PDF, 2007, http://www.cups-pdf.de/
[CUP07b]
CUPS,
http://www.cups.org/
Common
UNIX
Printing
System,
2007,
[HTM02] HTML2FO, HTML2FO: a HTML to XSL-FO converter, 2002,
http://sourceforge.net/projects/html2fo/
[ISO06] ISO, ISO/IEC 26300:2006, 2006,
http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?
csnumber=43485
[MED06] Media-Converter, Media Converter. Free and on-line. Convert
and split sound, ringtones, images, docs, 2006,
http://media-convert.com/convert/
[OAS05] OASIS, Members Approve OpenDocument as OASIS Standard,
2005, 23 Maggio 2005,
http://www.oasis-open.org/news/oasis_news_05_23_05.php
83
[OAS07] OASIS, Open Document Format for Office Applications
(OpenDocument) v1.1, 1 Febbraio 2007,
http://docs.oasis-open.org/office/v1.1/OS/OpenDocument-v1.1.odt
[OOo05] OpenOffice.org, Guida Introduttiva. Cos'è OpenOffice.org, 2005,
7 maggio 2005,
http://oooauthors.org/it/userguide2/GuidaIntroduttiva/0101GSCosaEOOo.pdf
[PDF06] pdfforge, PDFCreator, 2006,
http://www.pdfforge.org/products/pdfcreator
[PIX07] Pixware, XMLmind XSL-FO Converter version 4.2, 2007, 13
Dicembre 2007, http://www.xmlmind.com/foconverter/what_is_xfc.html
[UNI07] UNI - Ente nazionale italiano di unificazione,Documenti
elettronici: pubblicata la norma UNI CEI ISO/IEC 26300 sul formato
OpenDocument, 2007, 26 Gennaio 2007,
http://www.uni.com/uni/controller/it/comunicare/articoli/2007_1/odf_2630
0.htm
[W3C06a] W3C, Extensible Markup Language (XML) 1.0 (Fourth Edition)
Recommendation, 2006, 29 Settembre 2006, http://www.w3.org/TR/xml/
[W3C06b] W3C, Extensible Stylesheet Language (XSL) Version 1.1, 2006,
5 Dicembre 2006, http://www.w3.org/TR/xsl/
[W3C99] W3C, XSL Transformations (XSLT)Version 1.0, 1999,
16 Novembre 1999, http://www.w3.org/TR/xslt
[ZAM07a] ZamZar, Free Online file conversion, 2007,
http://www.zamzar.com/
[ZAM07b] ZamZar, Conversion Type, 2007,
http://www.zamzar.com/conversionTypes.php
84
Indice delle illustrazioni
Illustrazione 1: Struttura di un documento ODT..........................9
Illustrazione 2: OpenOffice.org, esportazione in formato PDF......20
Illustrazione 3: Schermata del convertitore on­line ZamZar........22
Illustrazione 4: Schermata del convertitore on­line MediaConverter .................................................................................................23
Illustrazione 5: Schermata del convertitore PDFCreator..............25
Illustrazione 6: Schermata del convertitore PrimoPDF................27
Illustrazione 7: Schermata della stampante virtuale CUPS­PDF. .28
Illustrazione 8: Documento 1 in formato ODT.............................49
Illustrazione 9: Documento 1 in formato PDF.............................50
Illustrazione 10: Documento 2 in formato ODT...........................51
Illustrazione 11: Documento 2 in formato PDF...........................52
85