//
// Questo file serve per pilotare il disegno in grafica SVG
// di un elemento path...
//
// Definisce la libreria di servizio svglib.
//
var svglib={versione:"20160422",comemichiamo:"?",
    xbr:"\u003cbr/\u003e",listap:[],xtable:[[0,0],[0,0]] };
//
// Questa funzione consente di aggiungere ai vari file script 
// anche un file che si chiami come il documento ( senza l'estensione
// l'estensione ".xhtml" o ".htm") ma ampliato dalla aggiunta ".js.txt".
// Appena agganciato questa libreria va attivato il metodo
// svglib.altroscriot();
//
svglib["altroscript"]=function(){
    var sc=document.createElement("script");
    var ausiliare,nomefile,questofile=document.location.href;
    if(0>questofile.lastIndexOf(".xhtml")
       )nomefile=questofile.substring(0,questofile.lastIndexOf(".htm"));
    else nomefile=questofile.substring(0,questofile.lastIndexOf(".xhtml"));
    svglib.comemichiamo=nomefile;
    ausiliare=nomefile+".js.txt";
    sc.setAttribute("type","text/javascript");
    sc.setAttribute("src",ausiliare);
    document.getElementsByTagName("head")[0].appendChild(sc); 
    }
//
// Queste funzioni servono a gestire una table standard in cui
// c'e' almeno una textarea e una marca svg contenente una
// marca image e una marca path. 
//
svglib.xtable[0][0]=function(questo){
       var padre=questo.parentNode;
       var nonno=padre.parentNode;
       var linput=nonno.getElementsByTagName("input");
       var imma=nonno.getElementsByTagName("image");
       imma[0].setAttribute("xlink:href",linput[0].value);
       imma[0].setAttribute("width",linput[1].value);
       imma[0].setAttribute("height",linput[2].value);
       }
//
svglib.xtable[0][1]=function(questo){
       var ss,st,ns,xpa;
       var padre=questo.parentNode;
       var nonno=padre.parentNode;
       var ltd=nonno.getElementsByTagName("td");
       var ltextarea=nonno.getElementsByTagName("textarea");
       var lpath=nonno.getElementsByTagName("path");
       ss=ltextarea[0].value;
       ltd[0].innerHTML="Sono pronto: "+ss;
       st=svglib.xtraduce(ss);
       ltd[1].innerHTML= st;
       //
       //  Uso il metodo svglib.esaminando(...) 
       //
       ns=svglib.esaminando(ltd[1]);
       ltd[2].innerHTML="ATTENZIONE ! Questo è il risultato ossia la stringa "+
       "che assegno all'attributo d del path : \u003cbr/\u003e( "+ns+" )";
       xpa=lpath[0];
       xpa.setAttribute("d",ns);
       ltd[3].innerHTML="Fatto ! Scrivo un numero a caso: "+Math.random();
       // 
       }
//
// Specifico le dimensioni della marca svg standard in modo
// da poterle cambiare ridefinendo il valore della finestra
// svglib.vxbox e svglib.vybox e la percentuale di 
// ridimensionamento nel documento HTML o XHTML e il
// colore della spezzata disegnata con l'elemento path.
//
svglib["vxbox"]=2000;
svglib["vybox"]=1000;
svglib["percento"]=50;
svglib["colorelinea"]="red";
//
// Crea una marca svg di struttura standard, contenente una
// immagine presa in rete ( il suo indirizzo e' dove )
// e un elemento path.
//
svglib["ricalca"]=function(dove,sfondo,imw,imh){
    var xl="\u003c",xg="\u003e";
    var xbox=svglib.vxbox,ybox=svglib.vybox;
    var largo=Math.round(xbox*svglib.percento/100),
        alto=Math.round(ybox*svglib.percento/100);
    var linea=svglib.colorelinea;
    var riempito="none";          // incolore
    if(arguments.length>4)linea=arguments[4];
    if(arguments.length>5)riempito=arguments[5];
    var svg=xl+"svg xmlns='http://www.w3.org/2000/svg' version='1.1' "+
      " xmlns:xlink='http://www.w3.org/1999/xlink' "+ 
      " width='"+largo+"' height='"+alto+
      "'  viewBox='0 0 "+xbox+" "+ybox+"' "+ 
      " style='background:"+sfondo+"' "+xg+
      xl+"image x='1' y='1' width='"+imw+"' height='"+imh+"' "+ 
      " xlink:href='"+dove+"' /"+xg+
      xl+"path stroke='"+linea+"' stroke-width='1' "+
      " fill='"+riempito+"' d='M 1 1 L "+xbox+" "+ybox+"' /"+xg+
      xl+"/svg"+xg;
      return svg; }
//
// Variabili di servizio configurabili direttamente.
//
svglib["a"]=1;
svglib["b"]=Math.sqrt(2);
svglib["c"]=Math.sqrt(3);
svglib["d"]=Math.sqrt(5);
svglib["e"]=Math.sqrt(6);
svglib["f"]=Math.sqrt(7);
svglib["g"]=Math.sqrt(8);
svglib["h"]=Math.sqrt(11);
svglib["i"]=Math.sqrt(12);
svglib["j"]=Math.sqrt(13);
svglib["k"]=Math.sqrt(14);
svglib["l"]=Math.sqrt(15);
svglib["m"]=Math.sqrt(17);
svglib["n"]=Math.sqrt(18);
svglib["o"]=Math.sqrt(19);
svglib["p"]=Math.sqrt(Math.PI);
svglib["q"]=Math.sqrt(20);
svglib["r"]=Math.sqrt(21);
svglib["s"]=Math.sqrt(22);
svglib["t"]=Math.sqrt(23);
svglib["u"]=Math.sqrt(24);
svglib["v"]=Math.sqrt(26);
svglib["w"]=Math.sqrt(27);
svglib["x"]=Math.sqrt(28);
svglib["y"]=Math.sqrt(29);
svglib["z"]=Math.sqrt(30);
//
// Il nome del Tag, il TagName, di cui fa la lista per analizzarla.
//
svglib["tagname"]="i";
//
// Il carattere che segnala che i dati si riferiscono ad un punto
// o comunque un punto ma dandogli la forma di freccia.
//
svglib["xpunto"]="^";
svglib["xfreccia"]="@";
svglib["tondo"]=10;
//
// Il carattere che segnala che nella posizione dell'ultimo
// punto disegnato va disegnato attorno a lui un cerchio...
// Il raggio del cerchio e' prefissato ma si puo' cambiare...
//
svglib["xcerchio"]="$";
svglib["raggio"]=10;
//
// Come disegnare le frecce ossia piu' o meno appuntite
// e piu' o meno lunghe ...
//
svglib["ffre"]=0.25;
svglib["pfre"]=50;
//
// Delimitare le parti utili per costruire il disegno
// con marche ammesse dall'HTML e' comodo se si scrive
// nel documento l'innerHTML da usare ma se si usano
// stringhe Javascript e' un po' scomodo usare le marche HTML.
// Piuttosto si possono simulare, scrivendo {i} e {/i}
// se il TagName e' i   oppure si puo' usare il carattere 
// bivalente cancelletto ossia # che quando e' in posizione pari
// rappresenta {i} e se e' in posizione dispari rappresenta {/i}
// e dunque bisogna stare attenti a non dimenticarne uno per non 
// mandare in confusione il traduttore...
// Insomma usare # e' un po' rischioso ma e' un modo conciso
// di scrivere...
//
svglib["xtraduce"]=function(sinp){
    var j,nk,tac=true,sout="";
    for(j=0;sinp.length>j;j++){
       nk=sinp.charCodeAt(j);
       if(nk==35){if(tac){sout+=String.fromCharCode(60,105,62);
             tac=!tac}
          else{sout+=String.fromCharCode(60,47,105,62);
             tac=!tac} }
       else{if(nk==123)nk=60;
          if(nk==125)nk=62;
          sout+=String.fromCharCode(nk);}
       } // fine traduzione
   return sout;}
//
// Funzione utile per eventuale caricamento di documenti di
// nome simile a quello che chiama il metodo svglib.michiamo()
//
svglib["michiamo"]=function(){
    var nome="?",questo=document.location.href;
    if(0>questo.lastIndexOf(".xhtml")
         )nome=questo.substring(0,questo.lastIndexOf(".htm"));
    else nome=questo.substring(0,questo.lastIndexOf(".xhtml"));
    svglib.comemichiamo=nome;
    return nome;
    }
//
// Per disegnare segmenti orientati con una freccia...
// Segnala eventuali errori degli argomenti.
//
svglib["freccia"]=function(traccia,ax,ay,axv,ayv){
    var p1,p2,dxn,dyn,dx,dy,dd,norma;
    var x=ax,y=ay,xv=axv,yv=ayv;
    if(isNaN(xv)){alert("In freccia errore! xv="+xv);xv=1} 
    if(isNaN(yv)){alert("In freccia errore! yv="+yv);yv=1} 
    if(isNaN(x)){alert("In freccia errore! x="+x);x=2} 
    if(isNaN(y)){alert("In freccia errore! y="+y);y=2} 
    dx=xv-x;dy=yv-y;
    norma=1/Math.sqrt(1.e-16+dx*dx+dy*dy);
    dx=dx*norma;dy=dy*norma;
    dxn=dy;dyn=-dx;
    p1=[dx+svglib.ffre*dxn,dy+svglib.ffre*dyn];
    p2=[dx-svglib.ffre*dxn,dy-svglib.ffre*dyn];
    dd=traccia+(Math.round(svglib.tondo*x)/svglib.tondo)+
        " "+(Math.round(svglib.tondo*y)/svglib.tondo)+
        " L "+Math.round(svglib.tondo*(x+svglib.pfre*p1[0]))/svglib.tondo+
        " "+Math.round(svglib.tondo*(y+svglib.pfre*p1[1]))/svglib.tondo+
        " "+Math.round(svglib.tondo*(x+svglib.pfre*p2[0]))/svglib.tondo+
        " "+Math.round(svglib.tondo*(y+svglib.pfre*p2[1]))/svglib.tondo+
        " "+(Math.round(svglib.tondo*x)/svglib.tondo)+
        " "+(Math.round(svglib.tondo*y)/svglib.tondo)+" ";
    return dd; 
    }
//
// Per disegnare cerchietti utili per riconoscere i punti a cui
// e' arrivato il disegno del path.
// Per evitare blocchi , in caso che gli argomenti non siano
// numeri vengono dati a loro valori convenzionali e si dovra'
// capire cosa non ha funzionato.
//
svglib["cerchietto"]=function(xx,yy,rr){
   var x,y,r;
   if(isNaN(xx))x=30;
   else{x=(Math.round(svglib.tondo*xx)/svglib.tondo)};
   if(isNaN(yy))y=30;
   else{y=(Math.round(svglib.tondo*yy)/svglib.tondo)};
   if(isNaN(rr))r=10;
   else{r=(Math.round(svglib.tondo*rr)/svglib.tondo)};
   return " M "+x+" "+(y+r)+" a "+r+" "+r+" 0 0 0 0 "+
   (-2*r)+" "+r+" "+r+" 0 0 0 0 "+(2*r)+"  "+" m 0 "+(-r)+" "; 
   }
//
// Per arrestare il calcolo e capire se il calcolo e'
// arrivato al punto di controllo dove attiva l'avviso.
//
svglib["ultimavviso"]="Nessun avviso";
svglib["avviso"]=function(sav){
   alert("Avviso:\n"+sav);
   svglib.ultimavviso=sav;
   return 0;}
//
// Per scrivere un commento qualsiasi e verificare
// che l'analisi sia arrivata a quel punto:
//
svglib["miocommento"]="Nessun commento";
svglib["commento"]=function(){
   if(1>arguments.length)alert("Pausa qui");
   else svglib.miocommento=arguments[0];
   return 0;}
//
// Per disegnare un rettangolo con un vertice dove e'
// arrivato il disegno.
//
svglib["quad"]=function(larg,alt){
    var largo,alto,sp;
    largo=Math.round(svglib.tondo*larg)/svglib.tondo;
    alto=Math.round(svglib.tondo*alt)/svglib.tondo;
    sp=" l "+largo+" 0 0 "+alto+" "+(-largo)+" 0 0 "+(-alto)+" ";
    //
    // Bisogna chiedere esplicitamente che il risultato sia ricopiato!
    // Serve quando si vuole usare subito questo sottodisegno che pero' 
    // puo' essere salvato e riutilizzato parecchie volte usando 
    // il metodo copia.
    //
    svglib.xcopia=[true];
    return sp;
    }
//
// Coordinate cartesiane assolute trasformate in relative ed
// eventualmente si puo' assegnare uno spostamento iniziale
// assoluto ossia con una M maiuscola.
//
svglib["inrelativi"]=function(vp){
    var j,sp,xa,ya,sx,sy;
    if(arguments.length>2)sp=
       " M "+arguments[1]+" "+arguments[2]+" l ";
    else{sp=" l "};
    xa=vp[0][0];
    ya=vp[0][1];
    for(j=1;vp.length>j;j++){
        sx=Math.round((vp[j][0]-xa)*svglib.tondo)/svglib.tondo;
        sy=Math.round((vp[j][1]-ya)*svglib.tondo)/svglib.tondo;
        if(vp[j].length>2){
           sp+=" "+vp[j][2]+" "+sx+" "+sy+" ";}
        else{ sp+=" "+sx+" "+sy+" ";}
        xa+=sx;
        ya+=sy;
        }
    //
    // Bisogna chiedere esplicitamente che il risultato sia ricopiato!
    // Serve quando si vuole usare subito questo sottodisegno che pero' 
    // puo' essere salvato e riutilizzato parecchie volte usando 
    // il metodo copia.
    //
    svglib.xcopia=[true];
    return sp;
    }
//
// Usa coordinate polari o coordinate cartesiane RELATIVE
// con eventuale spostamento iniziale assoluto.
//
// L'uso di coordinate relative e' molto vantaggioso
// perche' per spostare un intero disegno basta cambiare
// solo il punto iniziale del disegno.
//
// Per evitare l'uso di troppe cifre decimali si usa
// l'arrotondamento ma lavorando in coordinate relative
// gli arrotondamenti possono accumularsi e rendere
// impreciso il disegno.
//
// Per evitare l'accumulo degli errori di troncamento
// bisogna passare momentaneamene alle coordinate assolute
// ed arrotondate per calcolare lo spostamento che anche
// corregge un po' l'errore di trancamento in modo che
// gli errori non si accumulino.
//
// Usa coordinate cartesiane se il raggio polare ( l'elemento 
// zero di vp[j]) e' negativo. Se e' minore di -1000000 resta negativo
// ma aumentato di 1000000 ossia una quantita' esagerata nella 
// grafica; se invece e' negativo ma maggiore di -1000000
// viene considerata ascissa positiva. 
// In questo modo si possono ottenere sia ascisse positive 
// che negative.
//
// {i}svglib.relativi(200,[[1,15],[1,60]],150,150){/i}
//
// oppure usando i cancelletti:
//
// #svglib.relativi(200,[[1,15],[1,60]],150,150)#
//
svglib["relativi"]=function(scala,vp){
    var j,sp,ra,rx,phi,xphi,xa,ya,dxa,dya;
    var tasx,tasy,asx=0,asy=0,iasx=0,iasy=0;
    var liminf=-1000000;
    if(arguments.length>3)sp=
       " M "+arguments[2]+" "+arguments[3]+" l ";
    else{sp=" l "};
    //    
    for(j=0;vp.length>j;j++){
        // Se vp[j][0] e' una Array o se vp[j][1] e' una 
        // Array il primo elemento della Array deve essere 
        // una stringa che viene valutata.
        if(Array.isArray(vp[j][0]))with(Math){
             // alert("Sono qui");
             ra=eval(vp[j][0][0])
             }
        else {ra=vp[j][0]};
        if(Array.isArray(vp[j][1]))with(Math){
             // alert("Sono qui");
             xphi=eval(vp[j][0][1])
             }
        else {xphi=vp[j][1]};
        if(ra>0){
            phi=xphi*Math.PI/180;
            xa=scala*ra*Math.cos(phi);
            ya=scala*ra*Math.sin(phi);}
        else if(ra>liminf){
            xa=-ra*scala;
            ya=scala*xphi;}
        else{xa=(ra-liminf)*scala;
            ya=scala*xphi;}
        // 
        // Procedura di arrotondamento per minimizzare
        // la perdita di precisione causata dall'arrotondamento.
        // Calcola la posizione assoluta precisa asx e asy,
        // La arrotonda e calcola il conseguente 
        // spostamento relativo per avere la posizione 
        // assoluta arrotondata.
        //
        asx+=xa;
        asy+=ya;
        tasx=Math.round(svglib.tondo*asx)/svglib.tondo;
        tasy=Math.round(svglib.tondo*asy)/svglib.tondo;
        dxa=tasx-iasx;
        dya=tasy-iasy;
        iasx=tasx;
        iasy=tasy;
        // Per potere effettuare salti...
        // Eventualmente, con vp[j][2], si puo' usare m o l
        // scritti pero' sempre minuscoli.
        if(vp[j].length>2){
           sp+=" "+vp[j][2]+
           " "+(Math.round(dxa*svglib.tondo)/svglib.tondo)+
           " "+(Math.round(dya*svglib.tondo)/svglib.tondo)+" ";}
        else{sp+=
           " "+(Math.round(dxa*svglib.tondo)/svglib.tondo)+
           " "+(Math.round(dya*svglib.tondo)/svglib.tondo)+" ";}
        }
    //
    // Bisogna chiedere esplicitamente che il risultato sia ricopiato!
    // Serve quando si vuole usare subito questo sottodisegno che pero' 
    // puo' essere salvato e riutilizzato parecchie volte usando 
    // il metodo copia.
    //
    svglib.xcopia=[true];
    return sp;
    }
//
// Per disegnare una stella a 5 punte ruotata come si vuole
// ed in posizione relativa al punto in cui il disegno
// e' arrivato.
//
svglib["stella"]=function(raggio,phz,cx,cy){
    var j,x,dx,tx,y,dy,ty,phi,ss,rot=phz*Math.PI/180;
    x=raggio*Math.cos(rot)+cx;
    y=raggio*Math.sin(rot)+cy;
    //
    dx=Math.round(svglib.tondo*x)/svglib.tondo;
    dy=Math.round(svglib.tondo*y)/svglib.tondo;
    ss=" m "+dx+" "+dy+" l ";
    tx=dx;
    ty=dy;
    for(j=1;6>j;j++){
        phi=4*Math.PI*j/5+rot;
        x=cx+raggio*Math.cos(phi);
        y=cy+raggio*Math.sin(phi);
        //
        dx=Math.round(svglib.tondo*(x-tx))/svglib.tondo;
        dy=Math.round(svglib.tondo*(y-ty))/svglib.tondo;
        ss+=" "+dx+" "+dy+" ";
        tx+=dx;
        ty+=dy;
        }
    ss+=" m "+(Math.round(svglib.tondo*(cx-tx))/svglib.tondo)+
        " "+(Math.round(svglib.tondo*(cy-ty))/svglib.tondo)+" ";
    //
    // Bisogna chiedere esplicitamente che il risultato sia ricopiato!
    // Serve quando si vuole usare subito la stella che pero' 
    // puo' essere salvata come sottodisegno riutilizzabile parecchie
    // volte usando il metodo copia.
    //
    svglib.xcopia=[true];
    return ss;
    }
//
// Variante generalizzata della stella. Fa poligoni se passo vale 1
// o anche stelle con np punte a meno che il passo ossia i salti
// non siano tali da rifare il giro completo in meno di np passi.
//
svglib["poligono"]=function(np,passo,raggio,phz,cx,cy){
    var j,jj,x,dx,tx,y,dy,ty,phi,ss,rot=phz*Math.PI/180;
//    alert("In nuovopoligono");
//
    x=raggio*Math.cos(rot)+cx;
    y=raggio*Math.sin(rot)+cy;
    dx=Math.round(svglib.tondo*x)/svglib.tondo;
    dy=Math.round(svglib.tondo*y)/svglib.tondo;
    ss=" m "+dx+" "+dy+" l ";
    tx=dx;
    ty=dy;
    jj=0;
    for(j=0;np>j;j++){
        jj=(jj+Math.round(passo))%np;
        phi=2*Math.PI*jj/np+rot;
        x=cx+raggio*Math.cos(phi);
        y=cy+raggio*Math.sin(phi);
        dx=Math.round(svglib.tondo*(x-tx))/svglib.tondo;
        dy=Math.round(svglib.tondo*(y-ty))/svglib.tondo;
        ss+=" "+dx+" "+dy+" ";
        tx+=dx;
        ty+=dy;
        if(jj==0) break;
        }
    ss+=" m "+(Math.round(svglib.tondo*(cx-tx))/svglib.tondo)+
        " "+(Math.round(svglib.tondo*(cy-ty))/svglib.tondo)+" ";
    //
    // Bisogna chiedere esplicitamente che il risultato sia ricopiato!
    // Serve quando si vuole usare subito la stella che pero' 
    // puo' essere salvata come sottodisegno riutilizzabile parecchie
    // volte usando il metodo copia.
    //
    svglib.xcopia=[true];
    return ss;
    }
//
// Per fare un asterisco o parte di asterisco : per esempio:
// svglib.asterisco(true,500,500,100,0,12,3)
// oppure con spostamenti tutti relativi:
// svglib.asterisco(false,0,0,50,0,12,15)
// Per fare il triacontaedro usare 31.717474411461005 gradi ossia:
// svglib.asterisco(false,0,0,150,0,31.717474411461005,5)
//
svglib["asterisco"]=function(modo,cx,cy,raggio,grot,gbeta,npassi){
   var j,ss,rot,radrot,radbeta,xp,yp,xm,ym,dxp,dyp,dxm,dym;
   if(modo){ss=" M "+cx+" "+cy+" l ";}
   else{ss=" m "+cx+" "+cy+" l "};
   rot=grot;radbeta=gbeta*Math.PI/180;
   for(j=0;npassi>j;j++){
      radrot=rot*Math.PI/180;
      xp=raggio*Math.cos(radrot+radbeta);
      yp=raggio*Math.sin(radrot+radbeta);
      xm=raggio*Math.cos(radrot-radbeta);
      ym=raggio*Math.sin(radrot-radbeta);
      dxp=Math.round(svglib.tondo*(xp))/svglib.tondo;
      dyp=Math.round(svglib.tondo*(yp))/svglib.tondo;
      dxm=Math.round(svglib.tondo*(xm))/svglib.tondo;
      dym=Math.round(svglib.tondo*(ym))/svglib.tondo;
      ss+=" "+dxp+" "+dyp+" "+dxm+" "+dym+" "+(-dxp)+" "+(-dyp)+
         " "+(-dxm)+" "+(-dym)+" ";
      rot+=2*gbeta;}
   //
   svglib.xcopia=[true];
   return ss;
   }
//
// Per copiare una stringa o una Array come la assegno e spezzettarla...
// Opzionalmente specifico quale devono essere le
// coordinate dell'ultimo punto in modo che, se disegno una
// freccia, si conosca il punto di partenza della freccia.
// Il risultato e' una stringa di cui poi va fatto qualcosa...
//
svglib["xcopia"]=[false];
svglib["copia"]=function(miastringa){
    var ss,j;
    if(Array.isArray(miastringa)){ ss=" ";
        for(j=0;miastringa.length>j;j++)ss+=miastringa[j]+" ";}
    else ss=miastringa;
    //
    // Eventualmente aggiunge le coordinate considerate di partenza
    // per orientare la freccia
    //
    if(arguments.length>2)svglib.xcopia=[true,arguments[1],arguments[2]];
    else svglib.xcopia=[true];
    return ss;
    }
//
//  Questa e' la funzione fondamentale dell'oggetto svglib.
//  Al metodo svglib.esaminando va passato un oggetto del
//  documento HTML o XHTML analizzato.
//
svglib["esaminando"]=function(elemento){
    var A=10,B=11,C=12,D=13,E=14,F=15,G=16,H=17,I=18,J=19,K=20;
    var L=11,M=12,N=13,O=100,P=101,Q=102,R=103,S=104,T=105;
    var U=106,V=107,W=108,X=1000,Y=1001,Z=1002;
    var davalutare=" ";
    var j,k,xx=0,yy=0,xn=0,yn=0,v="",ns=0,ss="",rr=1,tt=1,traccia=" M ";
    var listai=elemento.getElementsByTagName(svglib.tagname);
    // 
    // I caratteri di controllo usati qui sono svglib.xpunto e 
    // svglib.xfreccia e svglib.xcerchio.
    //
    // Se ci sono, viene comunque valutata la stringa prima
    // e dopo il carattere di controllo mentre se non ci
    // sono viene valutata in blocco l'intera stringa ss.
    //
    // Lo spezzone valutato dall'eval puo' essere una serie di
    // istruzioni javascript separate dal carattere ; ed il
    // valore finale e' quello dell'ultima istruzione javascript.
    //
    // La valutazione serve anche a modificare l'ambiente 
    // ossia le lettere alfabetiche maiuscole A,B,C...Z e
    // quelle minuscole appartenenti alla svglib ossia 
    // svglib.a, svglib.b .... svglib.z.
    // Queste variabili sono usabili come parametri delle
    // espressioni...
    //
    for(j=0;listai.length>j;j++){
       ss=listai[j].innerHTML;
       ns=ss.length-1;
       k=ss.indexOf(svglib.xpunto);
       if(k>0){ with(Math){
                   xn=eval(ss.slice(0,k));
                   if(ns>k)yn=eval(ss.slice(k+1));
                   else yn=0;}
             v+=traccia+(Math.round(svglib.tondo*xn)/svglib.tondo)+
                " "+(Math.round(svglib.tondo*yn)/svglib.tondo);
           if(traccia.indexOf("L")>0){ 
              traccia=" ";}
           else { 
              traccia=" L ";}
           xx=xn;
           yy=yn;
           }
       else if(ss.indexOf(svglib.xfreccia)>0){ 
           k=ss.indexOf(svglib.xfreccia);
           with(Math){
             xn=eval(ss.slice(0,k));
             if(ns>k)yn=eval(ss.slice(k+1));
             else yn=0;
             }
           if(traccia.indexOf("M")>0 ){ 
              v+=traccia+(Math.round(svglib.tondo*xn)/svglib.tondo)+" "+
                 (Math.round(svglib.tondo*yn)/svglib.tondo);
              traccia=" L ";}
           else v+=svglib.freccia(traccia,xn,yn,xx,yy);
           xx=xn;
           yy=yn;
           }
       else if(ss.indexOf(svglib.xcerchio)>=0){
           k=ss.indexOf(svglib.xcerchio);
           with(Math){
                if(k>0){
                   if(isNaN(eval(ss.slice(0,k))))rr=svglib.raggio;
                   else{rr=round(svglib.tondo*eval(ss.slice(0,k)))/svglib.tondo;}
                   }
                else{ rr=svglib.raggio; }
             }
             if(ns>k){davalutare=ss.slice(k+1);
                 //
                 // La funzione o la serie di istruzioni servono a modificare
                 // l'ambiente ma non producono effetti immediati sul disegno
                 //
                 tt=eval(davalutare);
                 // Eventualmente qui si possono aggiungere istruzioni
                 // di debugging per capire cosa e' successo.
                 };
             //
             // Aggiunge nel disegno un cerchietto di raggio rr voluto.
             //
             v+=svglib.cerchietto(xx,yy,rr);
             traccia=" L "; }
       else{ tt=eval(ss);
             if(svglib.xcopia[0]){
                 //
                 // Qui il risultato della valutazione della stringa
                 // contribuisce al allungare il disegno
                 //
                 v+=tt+" ";
                 if(svglib.xcopia.length>2){
                    xx=svglib.xcopia[1];
                    yy=svglib.xcopia[2];
                    }
                 svglib.xcopia=[false];
                 traccia=" L "; }
             else traccia=" M "; }
       }
    // alert("Sono qui");
    return v;
    }
//
// Dunque per usare questa micro libreria bisogna passare un elemento 
// al metodo: svglib.esaminando(unelemento) e il risultato e'
// una stringa che e' assegnabile all'attributo d dell'elemento 
// path contenuto in un elemento svg del document HTML o XHTML.
//
// Ovviamente la funzione che ha usato il metodo svglib.esaminando 
// puo' fare l'uso che serve della stringa risultato prodotta da 
// questo metodo... Soprattutto appunto modificare l'attributo d 
// in un elemento path contenuto in un elemento svg ma anche 
// visualizzarla per individuare eventuali errori...
//
//
// Se si vuole, basta fare un documento scritto in modo coerente
// con questa funzione che va attivata alla fine con la
// istruzione : window.onload=svglib.lavora;
//
// Il documento deve contenere almeno una marca blockquote e
// dentro lei varie marche p.
//
svglib["lavora"]=function(){
    var ns,xpa,cisono,tipoggetto,ilrisultato="nulla";
    var listablo=document.getElementsByTagName("blockquote");
    var listap=listablo[listablo.length-1].getElementsByTagName("p");
    svglib.listap=listap;
    if(window.hasOwnProperty("altrefunzioni")){
      cisono="La variabile altrefunzioni"+
      " esiste e dunque ha trovato il file ausiliario. ";
      tipoggetto=(typeof altrefunzioni);
      if(tipoggetto=="function")ilrisultato=altrefunzioni();}
    else{cisono="La variabile altrefunzioni"+
      " non esiste e dunque NON ha trovato il file ausiliario";}
    listap[listap.length-1].innerHTML="Mi chiamo : "+
      svglib.michiamo()+svglib.xbr+
      " Il file ausiliario deve chiamarsi come questo ma "+
      "con in più .js.txt "+svglib.xbr+cisono;
    }
//