Ebbene sì, ammettiamolo: le stampe fatte dal browser fanno veramente schifo!

Non c'è modo di controllare se la stampa esce in Orizzontale o in Verticale, và a capo quando vuole lui, spezza le tabelle a metà che fà paura, non si riesce ad impostargli niente!

La verità è che il browser non è stato pensato per stampare, e le stampe che si riesce ad ottenre dal browser "nudo e crudo" fanno veramente pietà.

Certo, si può intervenire installando dei componenti server-side che consentono di produrre delle bellissime stampe, Crystal Report o Business Object producono dei risultati ottimi in quanto a questo, ma.... costano cari ed inoltre occorre installare le versioni Server sul server e distribuire gli applicativi client. E sappiamo già cosa ci risponderà il gestore del sito alla domanda "possiamo installare stà roba?".

Dopo una serie di (dis)avventure con i succitati prodotti, mi sono deciso finalmente a produrre qualche cosa che possa risolvere il problema. Quello che volevo IO era un prodotto/meccanismo che:

• consentisse il controllo del formato di stampa (Portrait/Landscape)
• permettesse di specificare font, dimensioni del carattere, grassetto e così via
• gestisse i salti pagina in modo "umano" permettendo (eventualmente) di forzarli
• gestisse le tabelle o (al minimo) gestisse le tabulazioni
• permettesse di specificare header e footer di pagina e la numerazione delle pagina
• non dipendesse da elementi esterni da installare sul server (ASP puro insomma)
• fosse (ragionevolmente) indipendentemente dal client dell'utente

Nà roba da ridere insomma (dirà qualcuno).
Bè, questo è quello che volevo io.

Word è un OLE Server, questo vuole dire che posso "generare" un documento Word esattamente come "attivo" una connessione ad un database, usando CreateObject(), quindi usare i metodi dell'oggetto Word per "pilotare" il documento stesso.

Questa soluzione comporta però alcuni problemi, innanzitutto Word deve essere installato sul server, cosa che non sempre è possibile, secondariamente i "metodi" di Word non sono la cosa più semplice del mondo da usare.
Questi due problemi, uniti al fatto che dopo mezz'ora di prove avevo 18 (!) sessioni di Word "zombie" sul server mi hanno fatto rapidamente scartare Word come soluzione valida.

L'RTF è un formato di documento "portabile" inventato da Microsoft all'inizio degli anni 90 per definire i testi che poi vengono trasformati nel sistema di help di Windows (.hlp).

Un file RTF è un file "ascii", cioè scritto in modo da essere (più o meno) leggibile direttamente, ma contiene dei tag, cioè degli indicatori che permottono di specificare come impostare il carattere, il paragrafo, la pagina etc. etc.

Diciamo che è un livello più "sofisticato" di HTML, dove oltre a specificare la formattazione del carattere e del paragrafo, possiamo specificare anche quella della pagina, quindi forzare una dimension/orientamento per la stessa, forzare i salti pagina e così via.

La cosa che interessa però è che è un testo ASCII, cioè può essere scritto direttamente senza l'ausilio di nessun programma specifico, esattamente come un buon WebMaster può scrivere un documento HTML senza dover usare nessun editor particolare.

Nota: per ulteriori informazioni sull'RTF vedere il relativo documento, oppure vedere la documentazione MSDN direttamente sul sito della Microsoft.

Per produrre il documento RTF posso utilizzare il FileSystemObject, quindi mi basta redirigere l'utente sul documento RTF prodotto perchè questo venga visualizzato nel browser utilizzando il visualizzatore predefinito, se l'utente ha installato Word verrà aperto Word, altrimenti il browser sceglierà quello che è disponibile al momento (anche il mefitico WordPad è in grado di interpretare l'RTF).

Il mio "generatore" sarà quindi costituito da una serie di funzioni, il cui scopo è quello di "incapsulare" la generazione del documento finale in una serie di procedure molto semplici e, soprattutto, riutilizzabili.

Ho bisogno poi dei Tag RTF che mi servono, siccome sono tanti preferisco averne un elenco e leggerli di volta in volta quando mi servono, in questo modo se voglio aggiungere un tag devo solo aggiungerlo all'elenco, il codice è predisposto per cercarlo nell'elenco e lo troverà.

La funzione "principale" è quella che preleva dall'elenco di tag quello richiesto al momento e lo "spara" nel file che stiamo costruendo.

Il meccanismo quindi si presenta così:

(1) devo scrivere un tag
      cerco il tag nell'elenco
      scrivo il tag
      ritorno a (1)

Dopo un pò di elucubrazioni sono arrivato al seguente elenco "minimo" di funzioni da implementare:

IniziaReport()	Inizializza il file e ci scrive dentro i tag di inizializzazione dell'RTF.
ImpostaPortrait()	Imposta la pagina in Portrait (normale A4 in verticale)
ImpostaLandscape()	Imposta la pagina in Landscape (A4 per il lungo)
AggiungiStile()	Aggiunge al file uno "stile" che può essere utilizzato nel testo (Normale, Titolo...)
ImpostaTabulatori()	Imposta i tabulatori da usare nel paragrafo successivo (per le tabulazioni)
ChiudiParagrafo()	Chiude il paragrafo attuale provocando uno "spazio" tra i testi
ScriviLinea()	Scrive una linea di testo senza andare a capo in fondo
ScriviLineaACapo()	Scrive una linea di testo ed aggiunge la "chiusa" per andare a capo successivamente
ScriviGrassetto()	Scrive il testo indicato in grassetto
ScriviCorsivo()	Scrive il testo indicato in corsivo (anche detto Italico)
UsaStile()	Imposta lo stile da usare per il testo successivo
ChiudiStile()	Cessa di utilizzare lo stile attuale, qualunque esso sia
ChiudiReport()	"chiude" il documento RTF attuale

Dopo molti tentennamenti ho deciso di lasciare perdere (per il momento) la gestione delle vere e proprie tabelle in RTF perchè sono un macello inimmaginabile, inoltre se Word incontra una tabella fatta non proprio come si deve và irrimediabilmente in crash.

Ognuna delle funzioni sopra descritte, ha la stessa struttura:

1. Leggo dall'elenco il tag che mi interessa
2. Scrivo il tag nel file
3. eventualmente: scrivo il testo fornitomi dall'utente a cui il tag si riferisce
4. eventualmente: chiudo il tag attuale

Quindi per prima cosa mi serve la funzione che legge dall'elenco il TAG che voglio. Per evitare di complicare le cose ho deciso di non utilizzare un database per memorizzare i tag, troppo complicato e fondamentalmente inutile, i Tag li memorizzo in un file ASCII, avente tale struttura:

Codice del Tag

@

testo che compone il tag

Il "@" separa il codice dal tag vero e proprio, questo significa che nè il tag, nè il codice possono contenere il carattere "@", in quanto a questo siamo a posto perchè nessun tag RTF contiene il "@".

/*
 * Cerca un tag specificato all'interno del file dei TAG 
 * Ritorna il tag cercato o NULL se non trovato.
 */
function LeggiTag( TagID, fileName )
{
   var fso;             // FileSystemObject
   var file;            // Fiile dei tag
   var elem;            // elementi del tag
   var tag = null;      // tag da ritornare
   var ro = / /g;       // RegularExpression usata per 'magniarè gli spazi
      
   // Creo un nuovo oggetto FileSystem
   fso=new ActiveXObject( "Scripting.FileSystemObject" );
   
   // accedo al file dei tag
   // N.B. non verifico se il file esiste... mica troppo bello
   file = fso.OpenTextFile( fileName )

   // elimino gli spazi all'interno del codice
   TagID = TagID.replace( ro, "" );
   
   // ciclo e leggo tutti i Tag
   while( ! file.AtEndOfStream )
   {
      // leggo il singolo Tag
      tag = file.ReadLine();
      
      // parserizzo suddividendo in Codice e Testo ed
      // elimino gli spazi
      elem = SeparaTag( tag, null );
      elem[0] = elem[0].replace( ro, "" );
      
      // verifico di aver trovato il tag che cercavo
      if( TagID == elem[0] )
      {
         // ritorno il tag
         tag = elem[1];
         break;
      }
   }

   // chiudo il file
   file.close();
   
   // ritorno il tag trovato o Null
   return tag;

}

/*
   SeparaTag
   
   Separa un Tag letto dal file nei suoi elementi
   un codice ed una stringa che vengono ritornati in un array
   costruito per l'occasione.
   
   Parametri:
   tag         è il tag letto dal file
   sep         è il carattere usato per dividere i due pezzi
   
*/
function SeparaTag( tag, sep )
{
   var ro;
   
   // se il separatore non è specificato assumo "@"
   if( sep == null )
   {
      ro = new RegExp( "@", "g" );
   }
   else
   {
      ro = new RegExp( sep, "g" );
   }

   return tag.split( ro );
   
}

L'ultima funzione "generica" che mi serve è la seguente: recupera un Tag dal file usando le due funzioni precedenti e lo scrive dentro nel file del report indicato.

/*
* Recupera un tag e lo scrive nel report
* Funzione che viene usato dappertutto
*
* tagFile è il nome del file dei tag da usare
* reportFile è un File già aperto.
* tag è l'ID del tag da inserire
*
*/
function ScriviTagNelReport( tagFile, reportFile, tag )
{
  var tmpTag;
  
  // recupero il tag di inizializzazione e lo scrivo nel file
  tmpTag = LeggiTag( tag, tagFile );
  reportFile.WriteLine( tmpTag );
  
}

Un documento RTF, come un documento HTML deve essere "aperto" e "chiuso" con i tag corretti, questi tag sono scritti nell'elenco dei tag e vengono recuperati dalle funzioni che io ho definito come IniziaReport() e ChiudiReport(), che a loro volta sono definite come segue:

/*
* Inizializza il report
* Crea il file denominato "reportFile" e scrive
* i tag di inizializzazione dell'RTF. I tag sono
* letti dal file indicato come "tagFile"
*
* Ritorna il nuovo oggetto File creato.
*/
function IniziaReport( reportFile, tagFile )
{
  var fso;        // FileSystemObject
  var fileReport; // file del Report
  
  // creo l'oggetto FSO
  fso = new ActiveXObject("Scripting.FileSystemObject");
  
  // creo il file del report
  fileReport = fso.CreateTextFile( reportFile );
  
  // recupero il tag di inizializzazione e lo scrivo nel file
  ScriviTagNelReport( tagFile, fileReport, "InizializzaReport" );
  
  // ritorno il report appena creato
  return fileReport;
  
}

/*
* Termina il report
* Scrive nel report indicato i tag di chiusura dell'RTF e
* chiude il file.
*/
function ChiudiReport( reportFile, tagFile )
{
  // recupero il tag di chiusura e lo scrivo nel file
  ScriviTagNelReport( tagFile, reportFile, "TerminaReport" );
  
  // chiudo il file
  reportFile.Close();
  
}

/*
* Imposta il formato pagina a Portrait
*/
function ImpostaPortrait( reportFile, tagFile )
{
  ScriviTagNelReport( tagFile, reportFile, "Portrait" );
}

/*
* Imposta il formato pagina a Landscape
*/
function ImpostaLandscape( reportFile, tagFile )
{
  ScriviTagNelReport( tagFile, reportFile, "Landscape" );
}

/*
* Scrive una linea senza mettere una fine paragrafo
* testo è il testo da scrivere
*
* N.B. 'tagFilè non è usato, ma viene richiesto per
* mantenere una certa coerenza con tutte le altre funzioni.
*/
function ScriviLinea( reportFile, tagFile, testo )
{
  reportFile.Write( testo + " ");
}

/*
* Scrive una linea aggiungendo la fine del paragrafo
*/
function ScriviLineaACapo( reportFile, tagFile, testo )
{
  reportFile.Write( testo );
  ChiudiParagrafo( reportFile, tagFile );
}

/*
* Inserisce la fine del paragrafo
*/
function ChiudiParagrafo( reportFile, tagFile )
{
  ScriviTagNelReport( tagFile, reportFile, "FineParagrafo" );
}

Siccome la tabella degli stili è quasi sempre la stessa, ho deciso di usare una tabella "fissa" definendo in anticipo tutti gli stili che mi servono ed "infilandoli" per default nel mio report, poi decidero quale stile usare di volta in volta.

Per selezionare uno stile mi basta riferirmi allo stile della tabella ma specificando la dimensione del font. Per fare questo devo raddoppiare la definizione degli stili, inserendo la prima volta lo stile nella tabella e la seconda volta lo stile con la dimensione del carattere.

Il codice che esegue la gestione degli stili è molto semplice:

/*
* Inserisce l'inizio della Tabella degli Stili
*/
function IniziaTabellaStili( reportFile, tagFile )
{
  ScriviTagNelReport( tagFile, reportFile, "InizioTabellaStili" );
}

/*
* Inserisce lo stile nella tabella
*/
function InserisciStile( reportFile, tagFile, stile )
{
  ScriviTagNelReport( tagFile, reportFile, stile )
}

/*
* Chiude la tabella stili
*/
function ChiudiTabellaStili( reportFile, tagFile )
{
  ScriviTagNelReport( tagFile, reportFile, "FineTabellaStili" );
}

/*
* Inserisce la tabella degli stili 'default'
*/
function InserisciTabellaStili( reportFile, tagFile )
{
  // inizializzo la tabella
  IniziaTabellaStili( reportFile, tagFile );
  
  // inserisco gli stili
  InserisciStile( reportFile, tagFile, "Titolo1" );
  InserisciStile( reportFile, tagFile, "Titolo2" );
  InserisciStile( reportFile, tagFile, "Titolo3" );
  InserisciStile( reportFile, tagFile, "Titolo4" );
  InserisciStile( reportFile, tagFile, "Normale" );
  InserisciStile( reportFile, tagFile, "Testo" );
  InserisciStile( reportFile, tagFile, "PieDiPagina" );
  InserisciStile( reportFile, tagFile, "Intestazione" );

  // chiudo la tabella degli stili
  ChiudiTabellaStili( reportFile, tagFile );
  
}

/*
* Inizia a scrivere con uno stile
*/
function IniziaStile( reportFile, tagFile, stile )
{
  ScriviTagNelReport( tagFile, reportFile, "Stile_" + stile );
}

/*
* Termina lo stile corrente
*/
function ChiudiStile( reportFile, tagFile )
{
   ScriviTagNelReport( tagFile, reportFile, "FineStile" );
}

Normale@{\f5\froman\fcharset0\fprq2 Times New Roman;}
Stile_Normale@{\f5\fs20 

/*
* Mette il testo in grassetto
*/
function AttivaGrassetto( reportFile, tagFile )
{
  ScriviTagNelReport( tagFile, reportFile, "InizioGrassetto" );
}

/*
* Mette il testo in corsivo
*/
function AttivaCorsivo( reportFile, tagFile )
{
  ScriviTagNelReport( tagFile, reportFile, "InizioCorsivo" );
}

/*
* Disattiva il grassetto
*/
function FineGrassetto( reportFile, tagFile )
{
  ScriviTagNelReport( tagFile, reportFile, "FineGrassetto" );
}

/*
* Disattiva il corsivo
*/
function FineCorsivo( reportFile, tagFile )
{
  ScriviTagNelReport( tagFile, reportFile, "FineCorsivo" );
}

La definizione di una tabulazione in RTF consiste fondamentalmente nell'inserire un tag che specifica dove deve trovarsi la tabulazione, ed un tag per usare la tabulazione stessa.

In RTF le tabulazione devono essere specificate in Twips (ventesimi di punto tipografico), per evitare problemi però preferisco convertira i dati internamente, permettendo così di specificare il tutto in millimetri.

/*
* Imposta una tabulazione
*/
function ImpostaTabulazione( reportFile, tagFile, tabulazione )
{
  var tabTwips;
  var tag;
  
  tabTwips = tabulazione * 56.7
  tag = LeggiTag( "Tabulazione", tagFile ) + tabTwips + " ";
  reportFile.WriteLine( tag );

}

/*
* Inizia una linea tabulata
*/
function IniziaLinea( reportFile, tagFile )
{
  ScriviTagNelReport( tagFile, reportFile, "InitTab" );
}

/*
* Chiude una linea tabulata
*/
function FinisciLinea( reportFile, tagFile )
{
  ScriviTagNelReport( tagFile, reportFile, "EndTab" );
}
/*
* Inserisce un carattere di tabulazione
*/
function InserisiciTab( reportFile, tagFile )
{
  ScriviTagNelReport( reportFile, tagFile, "Tab" );
}

Le IniziaLinea e FinisciLinea sono necessarie in quanto ogni linea deve essere raggruppata all'interno di un blocco definito da parentesi.

L'elenco dei Tag è il seguente:

InizializzaReport@{\rtf1\ansi
MarginiPagina@\margl1134\margr1134\margt1418\margb1134
TerminaReport@}
Portrait@\paperw11907\paperh16840
Landscape@\paperw16840\paperh11907
FineParagrafo@\par
InizioTabellaStili@{\fonttbl
Titolo1@{\f1\fswiss\fcharset0\fprq2 Arial;}
Titolo2@{\f2\fswiss\fcharset0\fprq2 Arial;}
Titolo3@{\f3\fswiss\fcharset0\fprq2 Arial;}
Titolo4@{\f4\froman\fcharset0\fprq2 Times New Roman;}
Normale@{\f5\froman\fcharset0\fprq2 Times New Roman;}
Testo@{\f6\froman\fcharset0\fprq2 Courier;}
PieDiPagina@{\f6\froman\fcharset0\fprq2 Courier;}
Intestazione@{\f6\froman\fcharset0\fprq2 Courier;}
FineTabellaStili@}
Stile_Titolo1@{\f1\fs48 
Stile_Titolo2@{\f2\fs40 
Stile_Titolo3@{\f3\fs36 
Stile_Titolo4@{\f4\fs24\b 
Stile_Normale@{\f5\fs20 
Stile_Testo@{\f6\fs20 
Stile_PieDiPagina@{\f7\fs16 
Stile_Intestazione@{\f8\fs16 
FineStile@}
InizioGrassetto@{\b 
FineGrassetto@}
InizioCorsivo@{\i 
FineCorsivo@}
Tabulazione@\tx
Tab@\tab 
InitTab@{
EndTab@}\par

Dim fileTag
Dim fileReport

' apro una connessione ad un database e creo un recordset
' ---- OMISSIS

' inizializzo il report
fileTag = Server.MapPath("Tag.Lst")
Set fileReport = IniziaReport( Server.MapPath("report.rtf"), fileTag )
ImpostaLandscape fileReport, fileTag
InserisciTabellaStili fileReport, fileTag
IniziaStile fileReport, fileTag, "Titolo1"
ScriviLineaACapo fileReport, fileTag, "Report di verifica"
ChiudiStile fileReport, fileTag
IniziaStile  fileReport, fileTag, "Normale"

' imposto le tabulazioni
ImpostaTabulazione fileReport, fileTag, 20
ImpostaTabulazione fileReport, fileTag, 40
ImpostaTabulazione fileReport, fileTag, 60
ImpostaTabulazione fileReport, fileTag, 80
IniziaLinea fileReport, fileTag

' visualizzo i titoli

InserisiciTab fileReport, fileTag
ScriviLinea fileReport, fileTag, "colonna 1"
InserisiciTab fileReport, fileTag
ScriviLinea fileReport, fileTag, "colonna 2"
InserisiciTab fileReport, fileTag
ScriviLinea fileReport, fileTag, "colonna 3"
InserisiciTab fileReport, fileTag
ScriviLinea fileReport, fileTag, "colonna 4"
FinisciLinea fileReport, fileTag

ScriviLineaACapo fileReport, fileTag, ""

' ciclo e stampo tutti i dati
Do While Not recordset.Eof

  IniziaLinea fileReport, fileTag

  InserisiciTab fileReport, fileTag
  ScriviLinea fileReport, fileTag, recordset.Fields("primo")
  
  InserisiciTab fileReport, fileTag
  ScriviLinea fileReport, fileTag, recordset.Fields("secondo")
  
  InserisiciTab fileReport, fileTag
  ScriviLinea fileReport, fileTag, recordset.Fields("terzo")
  
  InserisiciTab fileReport, fileTag
  ScriviLinea fileReport, fileTag, recordset.Fields("quarto")
  
  FinisciLinea fileReport, fileTag

  recordset.MoveNext
  
Loop

' eventuali totali etc.

Il codice del generatore
Il file dei tag
Esempio di funzionamento