function class_fade(obj_a, obj_b) {
	// i due oggetti coinvolti nel fading...
	this.obj_a = obj_a;
	this.obj_b = obj_b;
	
	// ...e le loro opacita' (sono le proprieta' di un mini-oggetto opacities, che le raggruppa per leggibilita').
	this.opacities = {obj_a : 100, obj_b: 0};
	
	// contatore dei passi del fading.
	this.counter = 0;
}

// il metodo start degli oggetti di classe class_fade prende 2 argomenti:
// 1) gradient, che specifica di quanto decrementare l'opacita' di A ad ogni ciclo di fade (ed e' quindi responsabile della
//    precisione del fading: piu' e' piccolo, piu' e' nitido il fading);
// 2) interval, che specifica - in msec - ogni quanto decrementare l'opacita' di A (ed e' quindi responsabile della velocita'
//    con cui l'effetto di fading si svolge: piu' e' piccolo, piu' e' rapido il fading).
class_fade.prototype.start = function(gradient, interval) {
	// 1. setto gli z-index dell'oggetto A e dell'oggetto B coinvolti nel fading entrambi a 0
	this.obj_a.style.zIndex = this.obj_b.style.zIndex = 0;
	
	// 2. setto le opacita' iniziali dei 2 oggetti rispettivamente a 100 e 0.
	set_opacity(this.obj_a, 100);
	set_opacity(this.obj_b, 0);
	
	// 3. avvio il fading
	this.fade(gradient, interval);
}

class_fade.prototype.fade = function(gradient, interval) {
	// 1. se l'opacita' dell'oggetto B non ha ancora raggiunto 100, decremento l'opacita' di A e incremento quella di B,
	if(this.opacities.obj_b < 100) {
		// 1.a aggiorno i valori delle opacita'
		// istruzioni un po piu' onerose! Decommentare solo se si desidera un fading piu' elaborato (e commentare le sottostanti 2 righe).
		this.opacities.obj_a = parseInt(100 - Math.pow(this.counter * gradient, 2)/100);
		this.opacities.obj_b = parseInt(100 - Math.pow(this.counter * gradient - 100, 2)/100);
		//this.opacities.obj_a -= gradient;
		//this.opacities.obj_b = 100 - this.opacities.obj_a;

		// 1.b e li applico agli oggetti
		set_opacity(this.obj_a, this.opacities.obj_a);
		set_opacity(this.obj_b, this.opacities.obj_b);
		
		// 2. incremento la proprieta' che conta il numero di cicli; utile se il calcolo dell'opacita' si basa su tale
		// contatore, omissibile altrimenti.
		this.counter++;
	} else {
		// 3. CONDIZIONE DI TERMINAZIONE
		return;
	}

	// 4. CHIAMATA SUCCESSIVA - creo un puntatore a questo oggetto (this) su cui invocare il metodo fade
	// dopo un intervallo pari a interval msec.
	var fader = this;
	setTimeout(function() {fader.fade(gradient, interval);}, interval);
}

/* DA RIFARE DOPO MODIFICHE DI PAOLO DEL 13-02-2009 */
/*
// classe class_slideshow; gli oggetti di questa classe estendono quelli di class_fade()
function class_slideshow() {
	// 1. creo un nuovo oggetto di classe class_fade()...
	this.Fader = new class_fade();
	// 2. ...a cui passo gli argomenti con cui costruisco l'oggetto corrente, di classe class_slideshow().
	class_fade.apply(this.Fader, arguments);
	// 3. sovrascrivo a true la proprieta' loop di questo oggetto di classe class_fade().
	this.Fader.loop = true;
}

class_slideshow.prototype.start = function(gradient, interval) {
	// 1. per avviare un'oggetto di classe class_slideshow() e' sufficiente avviare il suo sotto-oggetto di classe class_fade().
	this.Fader.start(gradient, interval);
}*/

// funzione accessoria che setta l'opacita' op all'elemento elem, eseguendo l'istruzione per IE o per FF.
function set_opacity(elem, value) {
	if (isIE)
		elem.style.filter = 'alpha(opacity=' + value + ')';
	else
		elem.style.opacity = value / 100;
}