// Idra: Ipertesto Dinamico per Racconti d'Avventura
// (C) 2000 Enrico Colombini
//
// Conversione in XHTML + CSS (a.k.a. Idra XC) (C) 2004 Giovanni Riccardi
// Conversione in XHTML Strict (a.k.a. Idra XS) (C) 2008 Syxtem
// Idra e' free software sotto la licenza GNU GPL, vedi infoIdra() per dettagli


// ===== Informazioni su Idra ===============================================


var idra = new Object()
idra.versione = "XS Beta 1"
idra.data = "Luglio 2008"
idra.copyright = "© 2000 Enrico Colombini -- Idra XC © 2004 Giovanni Riccardi -- Idra XS © 2008 Syxtem"


// ===== Variabili ==========================================================

var scelte = new Array() //scelte valide (stringhe contenenti codice o funzioni)
var nscelte = 0
var lscelte = 0 // aggiunto per gestire la lista delle scelte (GR)
var par = 0 // aggiunto per gestire la chiusura dei paragrafi (GR)
var qui = null //pagina corrente
var statoPrecedente = null //situazione prima dell'esecuzione della pagina corrente
var situazioneSalvata = null //usata per salvare se non funzionano i cookie
var idPagina = 0 //identificatore univoco (progressivo) di pagina
var nomeCookie = "Dati" //per il salvataggio su disco
var durataCookie = 60 //giorni
var mostraDebugger = 0
var comandoDebug = "" //ultimo comando dato al debugger

var idracontent = "";	// Aggiunto per visualizzare correttamente i contenuti delle pagine con innerHTML

// a disposizione dell'autore:

var v = new Object() //contiene le variabili di gioco come proprieta'


// ##########################################################################
// ##  Inizio area funzioni chiamabili dall'autore                         ##
// ##########################################################################


// ===== Funzioni di cambio pagina ==========================================


// Va alla pagina pag, che viene ricordata nella variabile qui
// come pagina corrente, usa OpzioniPagina(pag) se esiste, chiama:
// Intestazione(pag) se esiste, pag(), PiePagina(pag) se esiste,
// mostra le informazioni di debug se mostraDebugger = 1,
// prima di mostrare la pagina salva la situazione in statoPrecedente

function vai(pag) {
  qui = pag // ricorda la pagina
  statoPrecedente = creaStringaStato() //situazione prima di eseguire la pagina
  if (window.OpzioniPagina)  {
    apriPagina(OpzioniPagina(pag))
  } else {
    apriPagina()
  }
  if (window.Intestazione) { Intestazione(pag) }
  if (par == 1) {							// chiude eventuali paragrafi aperti  
  	idracontent += "<\/p>"; 	// nell'intestazione
	par = 0
  } 
  pag() //scrive la pagina
  if (window.PiePagina) { PiePagina(pag) }
  if (par == 1) {							// chiude eventuali paragrafi aperti  
  	idracontent += "<\/p>"; 	// nel Pi di Pagina
	par = 0
  } 
  if (mostraDebugger) { infoDebug() }
  chiudiPagina()  
  
  // se in modo debugging, seleziona il relativo campo di input
  if (mostraDebugger) { selDebugInput() }
}


// Mostra la pagina pag, senza ricordarla nella variabile qui; non chiama
// ne' Intestazione() ne' PiePagina() ma solo pag(), eventuali opzioni
// vanno esplicitamente passate come argomento (lo si puo' tralasciare)

function mostra(pag, opzioni) {
  apriPagina(opzioni)
  pag() //scrive la pagina
  chiudiPagina()  
}


// Esegue nuovamente la pagina corrente, cioe' quella ricordata nella variabile qui

function aggiorna() {
  vai(qui)
}


// Ridisegna la pagina corrente (qui) senza eseguirla, in modo che non cambi lo stato,
// lo fa partendo dallo stato precedente all'esecuzione e poi eseguendola

function ridisegna() {
  ripristinaStato(statoPrecedente)
  aggiorna() //avendo ripristinato lo statoPrecedente, ricostruisce quello attuale
}


// ===== Funzioni di creazione pagina =======================================


// Scrive l'eventuale titolo della pagina

function titolo(tit) {
  idracontent = idracontent + '\n<h1 id="pagetitle">' + tit + "<\/h1>\n";
}


// Scrive (parte del) testo della pagina, inclusi eventuali comandi HTML,
// accetta un numero variabile di argomenti e li stampa di seguito

function testo() {
	if (lscelte == 1) {
		idracontent += "\n<\/ul>";
		lscelte = 0
  	}
	if (par == 0) {
		idracontent += "<p>";
		par = 1
	}
  	for (var i = 0; i < arguments.length; i++) {		
		idracontent += arguments[i];
  	}
}


// Scrive una riga di testo centrato nella pagina
// Funzione aggiunta 

function testoCentrato() {
	if (lscelte == 1) {
		idracontent += "\n<\/ul>";
		lscelte = 0
  	}
	if (par == 1) {
		idracontent += "<\/p>";
		par = 0
	}
	idracontent += '<p class="center">';
  	for (var i = 0; i < arguments.length; i++) {
    	idracontent += arguments[i];
  	}
	idracontent += '<\/p>';
}

// Aggiunge una scelta al menu della pagina se la condizione cond e' vera,
// desc e' il testo da mostrare, act e' l'azione da compiere in caso di clic
// Se chiamata con due soli argomenti, sono desc e act (la condizione e' sempre vera).

// scelta(cond, desc, act)
// scelta(desc, act)

function scelta(p1, p2, p3) {
  var cond = p1; var desc = p2; var act = p3 //3 argomenti
  if (arguments.length == 2) { cond = 1; desc = p1; act = p2 } //2 argomenti
  if (cond) {
	if (par == 1) {				// chiude eventuali paragrafi aperti (GR)
		idracontent += "<\/p>";
		par = 0
	}
	if (lscelte == 0) {			//  apre una nuova lista di scelte (GR)
		idracontent += "\n<ul>";
		lscelte = 1
	}
    idracontent += "\n<li>"; //usa stile 'lista' mettendo la scelta in una lista a se' stante
    rinvio(desc, act) //aggiunge scelta nel testo
	idracontent += "<\/li>";
  }
} 


// Aggiunge una scelta nel testo, ricorda l'azione in scelte[], il link e'
// preceduto da idPagina per evitare problemi con la navigazione del browser

function rinvio(desc, act) {
  //associa al link una chiamata a eseguiScelta('idPagina:scelta')
  idracontent = idracontent + "\n<a href=javascript:eseguiScelta('" + idPagina + ":" + nscelte + "')" +
  " onMouseOver='return true'>" + desc + "<\/a>\n";
  scelte[nscelte] = act
  nscelte++
}


// Aggiunge la scelta "Continua"; se cond e' vera usa act1, altrimenti act2
// Se chiamata con un solo argomento, aggiunge la scelta in ogni caso

// continua(cond, act1, act2)
// continua(act)

function continua(p1, p2, p3) {
  var cond = p1; var act1 = p2; var act2 = p3 //3 argomenti
  if (arguments.length == 1) { cond = 1; act1 = p1 } //1 argomento
  if (cond) {
    scelta(cond, "Continua", act1)
  } else if (act2) {
    scelta(! cond, "Continua", act2) 
  }
}


// ===== Funzioni di apertura e chiusura pagina =============================


// Crea una nuova pagina con eventuali opzioni del <body> (es. colore), 
// assegna un identificatore univoco per rilevare problemi causati dai comandi 
// di navigazione del browser, azzera il contatore delle scelte

function apriPagina(opzioni) {
  idracontent = "";
  /*doc.open()
  doc.write('<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN"\n')
  doc.write('"http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">\n')
  doc.write('<html xmlns="http://www.w3.org/1999/xhtml">\n')
  doc.write('<head>\n')
  doc.write('<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />\n')
  doc.write('<meta name="Author" content="Enrico Colombini e Giovanni Riccardi" />\n')
  doc.write('<link rel="stylesheet" type="text/css" href="idra.css" />\n')
  doc.write('<body ')
  //doc.write('<html><head></head><body ')
  if (opzioni) { doc.write(opzioni) }
  doc.write(' >\n')*/
  idPagina++ //assegna un ID univoco
  nscelte = 0 // reset contatore scelte
}


// Termina la scrittura di una pagina

function chiudiPagina() {
  if (par == 1) {				// chiude un eventuale paragrafo aperto (GR)
	  idracontent += "\n<\/p>";
	  par = 0
  }
  if (lscelte == 1) {			// chiude un'eventuale lista di scelte aperta
	  idracontent += "\n<\/ul>";
	  lscelte = 0
  }
  document.getElementById("area").innerHTML = idracontent;  
  /*doc.write("\n</body>\n</html>")
  doc.close()*/
}


// ===== Funzioni ausiliarie ================================================


// Imposta opzioni per il salvataggio su disco

function opzioniCookie(nome, giorni) {
  nomeCookie = nome
  durataCookie = giorni
}


// Ritorna la pagina corrente (evita accesso diretto alle variabili del programma)

function pagina() {
  return qui
}


// Ritorna il nome di una pagina (funzione)

function nomePagina(p) {
  var s = p.toString() //lista la funzione corrispondente alla pagina
  // salta "function" e uno spazio, tiene fino alla parentesi esclusa
  return levaSpaziAttorno(s.substring(9, s.indexOf("(", 0)))
}


// Tira un dado a n facce (6 se non indicate), ritorna un intero tra 1 e n

function dado(n) {
  if (! n) { n = 6 } // default: 6 facce
  return Math.ceil(n * caso()) //non usare random(), dev'essere ripristinabile
}


// Elimina gli spazi attorno a una stringa (ritorna una nuova stringa)

function levaSpaziAttorno(s) {
  var inizio = 0
  var fine = s.length //primo carattere oltre la fine
  if (fine > 0) {
    while (s.charAt(inizio) == " ") { inizio++; }
    while (s.charAt(fine - 1) == " " && fine > inizio) { fine--; }  
  }
  return s.substring(inizio, fine)
}


// ##########################################################################
// ##  Fine area funzioni chiamabili dall'autore                           ##
// ##########################################################################


// ===== Avvio, riavvio e informazioni  =====================================


// Inizia il gioco

function gioca() {
  window.onerror = errore //attiva error handler
  qui = null //non e' aperta nessuna pagina
  v = new Object() //rialloca per evitare dati 'dimenticati' se riparte
  Inizia() //azzera variabili e va alla prima pagina
}


// Riparte dall'inizio

function riparti() {
  mostra(m_confermaRiparti) //se accetta, chiamera' gioca()
}


// Mostra pagina di informazioni, copyright e licenza di Idra

function infoIdra() {
  mostra(m_infoIdra, 'bgcolor="#FFFFCC"')
}


// ===== Effetto del clic su una scelta =====================================


// Verifica id di pagina per evitare problemi con Indietro e Avanti del browser,
// poi esegue l'azione contenuta nella scelta n, vedi esegui()

function eseguiScelta(s) {
  //riceve una stringa nel formato "id:scelta"
  var p = s.indexOf(":") //separa id di pagina e numero della scelta
  var id = s.substring(0, p)
  var n = s.substring(p + 1, s.length)
  if (id != idPagina) { //controlla che la pagina non sia cambiata
    mostra(m_cambiataPagina) //se lo e', avverte e poi rimette quelle giusta
  } else {
    esegui(scelte[n])
  }
}


// Esegue l'azione act, che puo' essere:
// - una stringa da eseguire, ad esempio "vai(P1)"
// - una funzione (pagina) a cui andare, ad esempio P1

function esegui(act) {
  if (typeof(act) == "function") { //se e' una funzione (pagina)
    vai(act)
  } else if (typeof(act) == "string") { //se e' una stringa
    eval(act)
  }
}


// ===== Salvataggio e ripristino ===========================================


// Verifica se puo' salvare, in caso affermativo esegue salva2()

function salva() {
  // verifica che non esista gia' una situazione salvata identica all'attuale
  var k = leggiSituazione() //eventuale situazione salvata
  if (k == null) { //nessuna situazione salvata, procede
    salva2()
  } else if (k == statoPrecedente) { //sono identiche, inutile salvare
    mostra(m_inutileSalvare)
  } else { //sono diverse, chiede conferma
    mostra(m_confermaSalva) // esegue salva2 se conferma, altrimenti ridisegna
  }
}


// Salva la situazione (prima dell'esecuzione della pagina) in un cookie

function salva2() {
  registraCookie(nomeCookie, statoPrecedente, durataCookie)
  if (leggiCookie(nomeCookie) == statoPrecedente) { //verifica se ha salvato
    situazioneSalvata = null //elimina eventuale situazione dalla variabile
    mostra(m_salvataCookie)
  } else {
    situazioneSalvata = statoPrecedente //non puo' usare i cookie, salva in una variabile
    mostra(m_salvataVar)
  }
}


// Chiede conferma se puo' riprendere la situazione salvata

function riprendi() {
  var s = leggiSituazione()
  if (s == null) {
    mostra(m_noSituazione)
  } else {
    mostra(m_confermaRiprendi)
  }
}


// Riprende la situazione salvata

function riprendi2() {
  var s = leggiSituazione()
  if (s) { //ricontrolla se ha riletto (tanto per sicurezza)
    ripristinaStato(s)
    aggiorna() //avendo ripristinato lo statoPrecedente, ricostruisce quello attuale
  } else {
    mostra(m_noSituazione)
  }
}


// Rilegge la situazione salvata in un cookie o in una variabile

function leggiSituazione() {
  var s
  if (situazioneSalvata) { //se ha salvato in una variabile, rilegge
    s = situazioneSalvata
  } else { //altrimenti prova a rileggere dal cookie
    s = leggiCookie(nomeCookie)
  }
  return s
}


// Crea una stringa contenente lo stato di gioco, cioe la situazione corrente:
// le proprieta' di v, "qui" come stringa e lo stato del generatore pseudocasuale

function creaStringaStato() {
  v._qui_ = nomePagina(qui) //salva anche pagina corrente
  v._caso_ = caso.stato //e stato del generatore pseudocasuale
  var s = ""
  for (var p in v) { //scandisce le proprieta' di v
    var pv = eval("v." + p) // valore contenuto
    if (typeof(pv) == "string") { //se e' una stringa e non un numero
      pv = '"' + segnaVirgolette(pv) + '"' //tra virgolette e con \" se necessari
    }
    s = s + "v." + p + "=" + pv + ";" //aggiunge al codice creato
  }
  return s
}


// Rimette il gioco nello stato descritto dalla stringa s

function ripristinaStato(s) {
  eval(s) //riassegna le proprieta' di v
  qui = eval(v._qui_) //recupera la funzione della pagina corrente e la ridisegna
  caso.stato = v._caso_ //ripristina lo stato del generatore pseudocasuale
}


// ===== Funzioni ausiliarie per uso interno ================================


// Estrae un numero pseudocasuale fra 0 (incluso) e 1 (escluso),
// parte con un valore casuale se riceve un argomento;
// caso.stato contiene lo stato corrente, salvabile e ripristinabile

function caso(iniz) {
  if (iniz) {
    caso.stato = (new Date()).getTime()
  }
  caso.stato = (caso.stato * 16807) % 2147483647
  return caso.stato / 2147483647.0
}
caso(1) //inizializza quando il programma viene caricato


// Scrive nella pagina un messaggio dell'interprete
// (tit=titolo, txt=testo fra separatori)

function scriviMessaggio(tit, msg) {
  idracontent += '\n<hr \/>';
  titolo(tit)
  idracontent = idracontent + "<p>" + msg + "<\/p>";
  idracontent += '\n<hr class="inner" \/>';
}


// Mostra una finestra di dialogo con un messaggio di errore,
// usata sia per l'error handler (3 arg) che come funzione generica (1 arg)

function errore(err, url, linea) {
  var s = "Errore: " + err
  if (url) { s = s + "\nURL = " + url } 
  if (linea) { s = s + "\nLinea = " + linea }
  alert(s)
  return true //non mostrare messaggio di errore del browser
} 


// Converte eventuali virgolette " contenute nella stringa s in \"

function segnaVirgolette(s) {
  var sv = ""
  var p
  while ((p = s.indexOf('"', 0)) != -1) { //se trova virgolette
    sv = sv + s.substring(0, p) + '\\' + '"' //aggiunge alla parte lavorata
    s = s.substring(p + 1, s.length) //toglie dalla parte restante
  }
  sv += s
  return sv
}


// Registra un cookie contenente i dati, con la durata specificata

function registraCookie(nome, dati, giorni) {
  var scade = new Date()
  scade.setTime(scade.getTime() + giorni * 1000 * 86400)
  var c = nome + "=" + escape(dati) +"; expires=" + scade.toGMTString()
  if (c.length <= 4095) {
    document.cookie = c
  } else {
    errore("il cookie e' troppo lungo (" + c.length + " byte, il massimo e' 4095)")
  }
}


// Legge un cookie, ritorna i dati o null se non lo trova

function leggiCookie(nome) {
  var dati = null
  var ck = document.cookie
  var id = nome + "="
  var p = ck.indexOf(id, 0) //cerca cookie con quel nome
  if (p != -1) { //se lo ha trovato
    p += id.length //salta nome e '='
    var sep = ck.indexOf(";", p) //cerca il separatore a fine dati
    if (sep == -1) { sep = ck.length }
    dati = unescape(ck.substring(p, sep))
  }
  return dati
}


// ##########################################################################
// ##  Messaggi standard                                                   ##
// ##########################################################################


function m_infoIdra() {
	idracontent = idracontent +
	'<div id="infoidra">\n'+
	"<h4>Realizzato con</h4>\n"+
	'<h1>Idra</h1>\n'+
	"<h4>(Ipertesto Dinamico per Racconti d'Avventura, v " + idra.versione + ")</h4>\n"+
	'<p class="center">Idra &egrave; ' + idra.copyright + "<\/p>\n"+
	
  	'<p><strong>Idra</strong> &egrave; <span>free software</span>; &egrave; lecito redistribuirlo e/o modificarlo secondo i termini della GNU GPL (Licenza Pubblica Generica GNU) come &egrave; pubblicata dalla Free Software Foundation; o la versione 2 della licenza o (a propria scelta) una versione successiva.'+
	
  	" Questo programma &egrave; distribuito nella speranza che sia utile, ma <strong>senza alcuna garanzia</strong>; senza neppure la garanzia implicita di <strong>negoziabilit&agrave;</strong> o di <strong>applicabilit&agrave; per un particolare scopo</strong>. Per ulteriori dettagli vedasi la licenza GNU GPL (Licenza Pubblica Generica GNU)."+
  
  	' Qualora non aveste ricevuto una copia della licenza GNU GPL insieme a questo programma, la potete richiedere alla Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA. La pagina Web della GNU &egrave; a <a href="http://www.gnu.org">www.gnu.org<\/a> (attenzione: facendo clic sui link si esce dal gioco).<\/p>\n'+
  
  	'<p>L&#39;autore &egrave; contattabile a <a href="mailto:erix@mclink.it">erix@mclink.it<\/a>; il manuale di Idra, eventuali aggiornamenti, correzioni o altre informazioni sono disponibili alla pagina <a href="http://www.cityline.it/personal/erix/idra.html">www.cityline.it/personal/erix/idra.html<\/a>; non &egrave; ovviamente possibile garantire che questi indirizzi rimangano validi in futuro.<\/p>\n'+
	
	'<p>Informazioni, aggiornamenti e aggiunte a <strong>Idra XC<\/strong> sono disponibili sul sito web <a href="http://www.composizioni.net/idraxc">http://www.composizioni.net/idraxc<\/a><\/p>\n'+
  
	"<p>La licenza GNU GPL si applica esclusivamente a Idra e alle sue estensioni, anche se fisicamente residenti in altri file; <b>non si applica</b> al contenuto letterario o artistico delle opere realizzate con Idra, per il quale valgono le condizioni di copyright e di licenza stabilite dal relativo autore.<\/p>\n"+
	'<p class="center">';
  	rinvio("Continua", "ridisegna()")
  	idracontent += "<\/p>\n<\/div>";
}

function m_confermaRiparti() {
  scriviMessaggio("Ricomincio?", "Abbandono la situazione corrente e ricomincio il gioco dall'inizio?")
  scelta("S&igrave;, ricomincia dall'inizio", "gioca()")
  scelta("No, torna al gioco", "ridisegna()")
}

function m_inutileSalvare() {
  scriviMessaggio("Inutile salvare", "La situazione salvata &egrave; identica a quella attuale, non c'&egrave; bisogno di salvare.")
  continua("ridisegna()")
}

function m_confermaSalva() {
  scriviMessaggio("Sovrascrivo?", "Esiste gi&agrave; una situazione registrata, la devo sostituire con quella corrente?")
  scelta("S&igrave;, registraci sopra", "salva2()")
  scelta("No, non registrare", "ridisegna()")
}

function m_salvataCookie() {
  scriviMessaggio("Salvataggio riuscito", "La situazione &egrave; stata registrata su disco in un &quot;cookie&quot;.<\/p><p>Sar&agrave; rileggibile per " + durataCookie + " giorni, a meno che non venga eliminata prima dal browser per eccessivo affollamento.")
  continua("ridisegna()")
}

function m_salvataVar() {
  scriviMessaggio("Impossibile salvare su disco", "Non &egrave; stato possibile registrare un &quot;cookie&quot; su disco.<\/p><p>La situazione &egrave; stata salvata invece in memoria e sar&agrave; rileggibile solo finch&eacute; non uscirai dal gioco.")
  continua("ridisegna()")
}

function m_noSituazione() {
  scriviMessaggio("Impossibile riprendere la situazione", "Non c'&egrave; alcuna sitazione salvata in precedenza.<\/p><p>Se ce n'era una in un &quot;cookie&quot; pu&ograve; darsi che esso sia stato cancellato dal browser per eccessivo affollamento.")
  continua("ridisegna()")
}

function m_confermaRiprendi() {
  scriviMessaggio("Abbandono e riprendo?", "Abbandono la situazione corrente e riparto da quella registrata in precedenza?")
  scelta("S&igrave;, riprendi quella registrata", "riprendi2()")
  scelta("No, torna al gioco", "ridisegna()")
}

function m_cambiataPagina() {
  scriviMessaggio('<font class="error">Problema: pagina errata</font>', "Il programma &egrave; confuso: probabilmente sei tornato indietro usando i comandi del browser invece che fare clic su una delle scelte elencate nella finestra.<p>Ora cerco di rimettere le cose a posto in modo che il gioco possa continuare.")
  continua("ridisegna()")
}


// ##########################################################################
// ##  Debugger                                                            ##
// ##########################################################################


// Mostra e nasconde le informazioni di debugging

function alternaDebugger() {
  mostraDebugger = ! mostraDebugger
  ridisegna();
}


// Mostra la pagina corrente, i valori delle variabili v., un campo di input
// per inserire comandi (o un nome di pagina) e il contenuto delle varie scelte;
// non vengono mostrate le variabili speciali che iniziano con un sottolineato

function infoDebug() {
  testo('<hr>')
  testo('<font class="debug">')
  testo("pagina=", nomePagina(qui)) //mostra nome della pagina corrente
  for (var p in v) { //elenca le proprieta' di v
    var pv = eval("v." + p) //valore contenuto
    if (typeof(pv) == "string") {
      pv = '"' + segnaVirgolette(pv) + '"' //tra virgolette e con \" se necessari
    }
    if (! (p.charAt(0) == "_")) { //salta variabili speciali
      testo(", v.", p, "=", pv)
    }
  }
  // crea campo di input e pulsante (= tasto Enter) per NS (4.5) e IE (5.0)
  testo('<form id="debugForm" name="debugForm" onSubmit="eseguiDebug(event); return false">')
  testo('<input type="text" id="debugInput" name="debugInput" /> ')
  testo('<input type="button" value="Esegui" onClick="eseguiDebug()" /> ')
  testo('<input type="button" value="Aggiorna" onClick="aggiornaDebug()" /> ')
  testo('<input type="button" value="Richiama" onClick="richiamaDebug()" />')
  testo('<br /></form>')
  // elenca le azioni associate alle scelte mostrate nella pagina
  var act
  for (var i = 0; i < nscelte; i++) {
    testo("Scelta ", (i + 1), ": &nbsp;")
    act = scelte[i]
    if (typeof(act) == "function") { //se e' una funzione (pagina)
      testo(nomePagina(act))
    } else if (typeof(act) == "string") { //se e' una stringa
      testo(act)
    }
    testo("<br />")
  }
  testo("</font>")
}


// Mette il cursore sul campo di input del debugger

function selDebugInput() {
	document.getElementById('debugInput').focus();
  /*parent.area.focus() //per netscape
  parent.area.document.debugForm.debugInput.focus()*/
}


// Esegue il comando impostato nel debugger, ridisegna la pagina;
// se il comando e' una singola parola composta da [A-Za-z0-9_]
// lo considera una pagina e ci va,  altrimenti lo considera codice e lo esegue

// Fase preliminare, necessaria altrimenti IE 5.0 ogni tanto si pianta

function eseguiDebug() {
  setTimeout("eseguiDebug2()", 50)
}

// Successiva fase di esecuzione

function eseguiDebug2() {
  // legge comando in input
  var com = levaSpaziAttorno(document.getElementById('debugInput').value)
  if (com) {
    comandoDebug = com //ne tiene una copia per poterlo richiamare
    if (contieneSolo(com.toLowerCase(), "abcdefghijklmnopqrstuvwxyz0123456789_")) {
      vai(eval(com)) //va alla nuova pagina
    } else {
      esegui(com) //esegue codice JavaScript e riesegue la pagina
      aggiorna()
    }
  }
}


// Aggiorna la pagina corrente, anche questo in due fasi per evitare problemi con IE

function aggiornaDebug() {
  setTimeout("aggiornaDebug2()", 50)
}

function aggiornaDebug2() {
  aggiorna()
}


// Richiama l'ultimo comando dato al debugger

function richiamaDebug() {
  document.getElementById('debugInput').value = comandoDebug
  selDebugInput() //rimette il cursore sul campo di input
}


// Controlla se la stringa s contiene solo i caratteri indicati nella stringa validi

function contieneSolo(s, validi) {
  var ok = 1
  for (var i = 0; i < s.length; i++) {
    if (validi.indexOf(s.charAt(i)) == -1) { //se non lo trova, non e' valido
      ok = 0 //carattere non valido
    }
  }
  return ok
}