Il nuovo sito del comune di Filago è stato realizzato con il CMS (Content Management System) Joomla FAP.

Il progetto Joomla FAP consiste in una versione accessibile e tradotta in italiano del noto CMS Joomla, abbiamo lavorato per completare Joomla FAP rendendolo conforme alla legge italiana sull’accessibilità dei siti internet destinati alle pubbliche amministrazioni.

Il risultato è un CMS pienamente conforme per quanto riguarda la parte disponibile al pubblico e parte del pannello di controllo limitatamente all’inserimento dei contenuti.

Il sito del Comune di filago è disponibile qui: http://www.comune.filago.bg.it

Come rendere accessibile Joomla

Il lavoro di “trasformazione” di Joomla è stato portato avanti su un doppio binario:

• preparare un template accessibile
• modificare il core (il nucleo) di Joomla per rimuovere il codice inaccessibile

In entrambi i casi il lavoro è partito dalla prima versione di Joomla FAP, dove era già stato preparato un template accessibile (anche se non conforme al XHTML strict come richiesto dalla legge Stanca) e il core era già stato parzialmente adattato.
Il lavoro sul template è stato probabilmente il meno oneroso, in termini di tempo e difficoltà tecniche. Molto più difficile è stato rimuovere dal core tutti i frammenti di codice non conforme, e in questo non ci è venuto in aiuto il codice di Joomla, che risente di vistosi errori progettuali che mischiano business logic e layout a frammenti di codice HTML.
Il core è stato modificato in diversi punti, sopratutto nel modulo com_content, responsabile della generazione delle pagine degli articoli, dal quale sono state rimosse tutte le tabelle inutili sostituendole con dei tag “div”.

Parecchie modifiche sono state anche fatte all’interno dei tag: molti attributi sono infatti deprecati in XHTML strict e hanno reso necessario lo spostamento degli stessi all’interno di stili inline, laddove possibile.

Il lavoro continua sui componenti

Quello che rende Joomla uno dei CMS più utilizzati al mondo è la grande disponibilità di moduli e componenti di terze parti che ne aumentano le funzionalità, alcuni di questi moduli sono assolutamente indispensabili per un moderno CMS (per es. forum e newsletter).
Il lavoro è quindi continuato su alcuni dei principali moduli per renderli anch’essi accessibli.

Come validare l’input degli utenti

Avere un core e un template accessibili purtroppo non basta: se infatti gli utenti che inseriscono i contenuti non sono vincolati quanto meno al rispetto formale della sintassi del codice XHTML strict, i contenuti da essi inseriti possono invalidare tutto il sito.
Abbiamo quindi modificato in più punti l’editor wysiwyg di Joomla TinyMCE in modo da costringerlo a produrre nei limiti del possibile del codice XHTML strict.
Questo ha comportato la rinuncia all’attributo target nei link, che permette di aprire i collegamenti in una nuova finestra. Tralasciando le diatribe e le perplessità sul merito dell’argomento, questo problema rimane un punto da risolvere, e i mezzi tecnici (facendo ricorso a codice javascript) non mancherebbero.

Conclusioni

Joomla FAP in questa nuova versione rappresenta una ulteriore passo avanti verso un CMS open source ricco di funzionalità, tradotto completamente in italiano e ragionevolmente conforme alla normativa italiana sull’accessibiltà dei siti internet, almeno per quanto riguarda la parte accessibile al pubblico (front-end).
Rimangono alcuni problemi da risolvere e sicuramente molti bug da sistemare, così come un adeguamento del pannello di amministrazione (il back-end) sarebbe sicuramente auspicabile.
Siamo ovviamente disponibili per qualsiasi servizio di installazione e configurazione nonchè per la creazione di moduli e componenti.

Download

Il codice è ospitato sul forge ufficiale di Joomla e scaricabile tramite svn:

svn checkout http://joomlacode.org/svn/joomlafap
Non siamo noi gli amministratori del progetto, per istruzioni su come scaricarlo e installarlo, fate riferimento al sito:

Joomla.it

Supporto commerciale

Siamo disponibili a fornire supporto commerciale su Joomla FAP per:

• installazione
• configurazione e personalizzazione
• creazione moduli e componenti ad hoc
• training
• creazione di temi grafici accessibili

Contattateci per un preventivo gratuito!

Chi non ha mai sentito parlare di Joomla?

Si tratta sicuramente di uno dei piú diffusi CMS open source, forse proprio il piú diffuso, se considerato insieme al suo cugino Mambo.

Purtroppo lo sviluppo di Joomla procede abbastanza lentamente, vista la mole del progetto, e questa lentezza causa non poche difficoltá a chi, come noi in Italia, é costretto ad inseguire le trovate di fantasiosi (e spesso incompetenti) legislatori.

Le pubbliche amministrazioni e l’accessibilitá

Mi riferisco alla legge sull’accessibilitá dei siti web, nota come legge “Stanca” dal nome dell’incompetente del legislatore di turno.

La legge, ha avuto l’innegabile merito di obbligare i creatori di siti web che realizzano siti e applicazioni per le pubbliche amministrazioni al rispetto di una serie di regole tese a favorire l’accesso al web da parte delle persone disabili.

Alcune di queste regole fanno parte del bagaglio di buone pratiche comune a qualsiasi serio professionista del settore e si rifanno a norme internazionali note da diverso tempo ed elaborate da enti prestigiosissimi come il W3C, altre sono invece frutto del tentativo di giustificare l’esistenza di qualche burosauro ministeriale.

Basta cantinari!

Il rispetto di queste norme ha il grande pregio di tagliare automaticamente fuori dal mercato tutti i siti fatti da “l’amico dell’amico” che hanno infestato per anni il web italiano.

Ormai chiunque puó diventare un web publisher semplicemente aprendosi un blog su uno dei tanti fornitori gratuiti, senza doversi preoccupare dei dettagli tecnici, mentre per le applicazioni piú complesse e i progetti di un certo rilievo, la strada rimane aperta solo per i professionisti del settore.

Joomla e l’accessibilitá

Come dicevo poc’anzi, Joomla soffre il fatto di essere un progetto maturo, nato in tempi in cui l’accessibilitá non era ancora in cima alle prioritá degli sviluppatori, l’adeguamento del codice procede a ritmi serrati ma segue le norme e gli standard internazionali e non quelle partorite dalla fervida immaginazione dei nostri geniali tecnocrati.

Se a ció si aggiunge che il codice di Joomla non consente purtroppo una separazione chiara tra business logic e application logic o peggio tra contenuti e presentazione degli stessi, é facile prevedere come passerá probabilmente parecchia acqua sotto i ponti prima che una versione aggiornata di Joomla conforme alla legge “Stanca” sia disponibile in lingua italiana.

La risposta italiana: Joomla FAP

Un gruppo di programmatori italiani riuniti nel sito joomla.it ha quindi intrapreso l’arduo compito di rendere conforme alla legge “Stanca” la versione italiana di Joomla. Da questi sforzi è nato il progetto Joomla FAP (joomla for all people), che però è stato più o meno abbandonato dopo avere comunque fatto dei notevoli passi avanti.

Segue….

The answer is easy, since your ISP normally charge for disk space and not for CPU usage, nowaday it’s the disk space shortage that more freqently happens.

The approach described here, permits you to generate “on the fly” all the scaled images you need for your site, just using standard PHP functions as provided from the GD library.

Before you start

You should check that your php_info(); function output has a section concerning GD: it should look like this:

gd

If you see something similar then you’re ok, else you should check for your PHP installation or change ISP.

This script was tested under Linux, I don’t know if it works under other OS’s (but why should’nt?)

The idea

The idea is quite simple, and is not particularly original (I took some code from other projects), I prepared a flexible script that can both accept parameters via GET or POST requests or read values from already defined variables.

The script can hence works standalone or included from other scripts.

Imagine you have an image that you need to resize on the fly, the image is stored sa images/image1.jpg under your document root, imagine also that the PHP script is called getthumb.php and is stored directly under the document root, to get a resized image 100 px wide you just call this url: http://www.yoursite.com/getthumb.php?width=100&img=image1.jpg

you usually want to mantain height/width ratio without distorcing the image, this is why you can specify only one dimension (x or y) and the script will do all the calculations for you.

Of course you can also save the thumbnail to disk, but this is normally accomplished through a calling script, just define the following vars in the calling script:

 * @param   string  $img_path image file path, relative to this script, if not
 *                            set, the next is checked on GET
 * @param   string  $img urlencoded image file path, relative to this script
 *                      (in vncms should be 2 level depth)
 * @param   integer $width max width
 * @param   integer $height max height
 * @param   string  $jpgfilename optional filename to store image in, if
 *                            not given, image is outputted to the browser

Finally, the code!

 
/**
 * @copyright 2005 Alessandro Pasotti 
 * @license GPL
 * @author  Alessandro Pasotti (some source grabbed somewhere)
 *
 * Read an image file and send a scaled thumbnail to the browser
 * default to 150 px width.
 *
 * This file can also be included, in this case, define vars in the calling script
 *
 * @param   string  $img_path image file path, relative to this script, if not
 *                            set, the next is checked on GET
 * @param   string  $img urlencoded image file path, relative to this script
 *                      (in vncms should be 2 level depth)
 * @param   integer $width max width
 * @param   integer $height max height
 * @param   string  $jpgfilename optional filename to store image in, if
 *                            not given, image is outputted to the browser
 *
 *
 * Example calls:
 *
 * getthumb.php?img=../../images/logo.jpg              --> default to max 150 (w or h)
 * getthumb.php?img=../../images/logo.jpg&height=200   --> resize to 200px height
 *
 *
 */
 
 
// Constants
define('DEF_WIDTH',     150);  // default
define('DEF_HEIGHT',    150);  // default
define('ALLOWED_WIDTH', 1024); // no tampering: set up a max
define('ALLOWED_HEIGHT',768);  // no tampering: set up a max
define('DEF_QUALITY',   90);   // default quality
 
define('DEBUG', false);
 
 
// I put this here to avoid any external dependency
if(!function_exists('__clean')) {
  function __clean($s, $len){
      if(!isset($s)) return null;
      $s = substr($s, 0, $len);
      if(ini_get('gpc_magic_quotes') != 1) $s = addslashes($s);
      $s = escapeshellcmd($s);
      return $s;
  }
}
 
// Get image location if not defined elsewhere
if(!isset($image_path))  $image_path = urldecode(stripslashes(__clean($_GET['img'], 256)));
if(!isset($width))       $width      = __clean($_GET['width'], 4);
if(!isset($height))      $height     = __clean($_GET['height'], 4);
 
// if both are not defined:
if(!$width && !$height) {
  $width = DEF_WIDTH;
  $height= DEF_HEIGHT;
}
 
if($width) $width   =  min(ALLOWED_WIDTH, $width);
else $width = ALLOWED_WIDTH;
if($height) $height =  min(ALLOWED_HEIGHT, $height);
else $height = ALLOWED_HEIGHT;
 
 
define('MAX_HEIGHT', $height);
define('MAX_WIDTH' , $width);
 
 
// Load image
$img = null;
$imginfo = getimagesize($image_path);
$imgtype = $imginfo[2];
 
$ext = strtolower(end(explode('.', $image_path)));
if ($imgtype == IMAGETYPE_JPEG) {
    $img = @imagecreatefromjpeg($image_path);
} else if ($imgtype == IMAGETYPE_PNG) {
    $img = @imagecreatefrompng($image_path);
    //echo "IMGEBASE " . IMAGE_BASE . ' path: ' .  $image_path; exit;
// Only if your version of GD includes GIF support
} else if ($imgtype == IMAGETYPE_GIF) {
    $img = @imagecreatefromgif($image_path);
}
 
// If an image was successfully loaded, test the image for size
if ($img) {
 
    // Get image size and scale ratio
    $width = imagesx($img);
    $height = imagesy($img);
    $scale = min(MAX_WIDTH/$width, MAX_HEIGHT/$height);
    if(defined('DEBUG') && DEBUG) {
      user_error("thumbnails.php - IMAGE: $image_path  WIDTH: $width HEIGHT: $height SCALE: $scale<hr />");
      exit;
    }
 
    // If the image is larger than max shrink it
    if ($scale < 1) {
        $new_width = floor($scale*$width);
        $new_height = floor($scale*$height);
 
        // Create a new temporary image
        $tmp_img = imagecreatetruecolor($new_width, $new_height);
 
        // Copy and resize old image into new image
        imagecopyresized($tmp_img, $img, 0, 0, 0, 0,
                         $new_width, $new_height, $width, $height);
        imagedestroy($img);
        $img = $tmp_img;
    }
}
 
// Create error image if necessary
if (!$img) {
    $img = imagecreate(DEF_WIDTH, DEF_HEIGHT);
    imagecolorallocate($img,255,255,255);
    $c2 = imagecolorallocate($img,255,0,0);
    imageline($img,0,0,DEF_WIDTH,DEF_HEIGHT,$c2);
    imageline($img,DEF_WIDTH,0,0,DEF_HEIGHT,$c2);
}
 
if(!$jpgfilename) {
  // Display the image
  header("Content-type: image/jpg");
  imagejpeg($img, null, DEF_QUALITY);
  exit;
} else {
   if(defined('DEBUG') && DEBUG) {
      echo "thumbnails.php - saving to $jpgfilename<hr>";
  }
  imagejpeg($img, $jpgfilename, DEF_QUALITY);
}

I hope you find this small script useful, it’s really very flexible and you can use it freely as you like.

Happy resizing!

Per una descrizione dettagliata relativa all’installazione su una SuSE 10 vedi l’articolo (in inglese): Mapserver webgis installation on SuSE 10

Prerequisiti

• PHP installato con tutti i file include, a seconda della distribuzione potrebbe essere necessario installare i pacchetti “devel”
• librerie gdal latest
• librerie libgd latest
• librerie proj4 latest (copiare projects.h from /usr/include to /usr/lib !!!!)
• librerie ming (ming-0.2a), se si vuole usare l’esportazione in formato Macromedia Flash
• postgis se si vuole salvare i dati geografici in postgresql

ed ecco la stringa di compilazione


./configure
--with-ming=/downloads/ming-0.2a
--with-wfs
--prefix=/usr
--with-proj=/usr/lib
--includedir=/usr/include
--with-gdal=/usr/local/bin/gdal-config
--with-ogr=/usr/local/bin/gdal-config
--with-php=/usr/local/include/php
--with-mygis=yes
--with-wfsclient
--with-wmsclient
--with-postgis


se non ci sono errori, prosegui con make&&make install

Buona fortuna

Occorre preparare due file di configurazione diversi sia per apache (httpd.conf) sia per PHP (php.ini).

Nel mio caso ho dovuto anche caricare (dinamicamente da uno script PHP) delle estensioni diverse, quindi il link simbolico.


# switch to php 4
rm /usr/local/lib/php.ini
cp /usr/local/lib/php.ini.php4 /usr/local/lib/php.ini
cp /usr/local/apache2/conf/httpd.conf.php4 /usr/local/apache2/conf/httpd.conf
rm /usr/local/lib/php/extensions/php_mapscript.so
ln -s /usr/local/lib/php/extensions/php_mapscript-php4.so /usr/local/lib/php/extensions/php_mapscript.so
service httpd restart


La home page del progetto LampoWeb

La home page del progetto ming

Code samples

Questo codice produce la homepage del progetto LampoWeb.

Docbook è un un formato XML che permette di scrivere testi, anche complessi, e di trasformarli in diversi altri formati, per esempio (X)HTML, PDF, JPEG, RTF ecc.

La trasformazione avviene normalmente in due passaggi: da XML a XSL-FO e da XSL-FO al formato desiderato.

Qualche link utile:

• DocBook XSL: The Complete Guide
• Transformations
• DocBook
• Writing Documentation Using DocBook

Htmldoc è un programma scritto in C, distribuito con doppia licenza (GPL: solo sorgenti, commerciale: binari e sorgenti con supporto) che permette di convertire documenti html in PDF.

Il programma può funzionare in tre modalità:

1. riga di comando
2. GUI (windows e Linux)
3. pipe (comodo per lo scripting lato server)

Visita il sito web del progetto.

Ho fatto qualche esperimento e le prime impressioni sono buone:

Pregi:

• Velocissimo
• Open source e gratuito, se lo compili da solo
• È possibile specificare header, footer ed eventuali loghi o immagini di sfondo
• Supporta le tabelle innestate (con qualche limitazione)
• Supporta l’allinamento per le immagini in linea, cioè il testo fluisce attorno all’immagine

Difetti:

• Non permette di includere font non standard
• Non supporta stili e CSS, però permette di formattare l’HTML con i vecchi tag FONT e BGCOLOR
• Non supporta la ripetizione sulle intestazioni delle tabelle

Installazione e compilazione

L’installazione è abbastanza semplice, occorre scaricare i sorgenti, scompattarli e lanciare make seguito da su -c "make install"

Un esempio a riga di comando

echo "<h1><font color="red">Ciao mondo</font></h1>" | htmldoc --no-compression -t pdf14 --quiet --jpeg --webpage --bodycolor '#aaaaaa' --color - > htmldoc_test.pdf

Fai clic qui per vedere il risultato.