Newsgroup: it.comp.lang.javascript
Titolo: SetInterval

Salve a tutti
la definizione del manuale Javascript di Netscape sostiene che si possono 
passare argomenti alle funzioni chiamate da setInterval:
setInterval(function, msec[, arg1[, ..., argN]])
io ho scritto questo codice
var intervalHandler=setInterval("dhtm_appro()",this.msec,5);
ma Il debugger di mozzilla continua a darmi il parametro di dhtm_appro
(param) come void (anche Opera).
Qualcuno mi può dire dove sbaglio?

 var intervalHandler=setInterval("dhtm_appro()",this.msec,5);
devi fare:
var intervalHandler = setInterval(dhtm_appro, this.msec, 5);
oppure:
var intervalHandler = setInterval("dhtm_appro(5)", this.msec);
Il primo modo funziona solo con Netscape, per cui è consigliato 
utilizzare il secondo.
Gaetano Bigliardi

 utilizzare il secondo.
Detto questo suppongo che sia impossibile mandargli un oggetto come 
parametro... :(
Mi sa che il mio progetto sta naufragando, grazie comunque per l'aiuto :)

 parametro... :(
No, se scrivi nel secondo modo funziona:
var intervalHandler = setInterval("dhtm_appro(5)", this.msec);
ovvero: il parametro lo passi direttamente scrivendolo all'interno della 
stringa.
Gaetano

 parametro... :(
Puoi passare come parametro il nome dell'oggetto. Ad esempio:
setInterval("myFunc(myObj)", 1000)
assicurati di aver impostato l'oggetto con qualcosa del tipo:
myObj = "Ciao ciao";
Oppure se l'oggetto dev'essere un campo di input di un form puoi fare:
setInterval("myFunc(document.myForm.myControl)");
Gaetano

 setInterval("myFunc(myObj)", 1000)
Ti ringrazio per l'aiuto, ma sembra che non ci sia proprio verso.
Io dovrei in realtà fare una cosa del genere
this.intervalHandler=setInterval("dhtm_appro(this)",this.msec);
Visto che l'interval lo setto dentro un oggetto user-defined che ho 
creato io e volevo passare alla funzione una reference all'oggetto 
stesso. 
L'idea è che la funzione dhtm_appro quando ha finito il suo lavoro si 
premura di stoppare l'iterazione dell'interval.
Facendo come dici tu al debbugger di mozzilla arriva un oggetto del tipo 
{window}, cioè una reference alla window corrente invece di un 
riferimento all'oggetto stesso (?!?).
Ho provato anche a fare una copia interna del puntatore all'oggetto tipo:
var mySelfref=this;
this.intervalHandler=setInterval("dhtm_appro(mySelfRef)",this.msec);
Ma in questo caso ottengo un errore del tipo 'mySelfRef is not defined'.
Credo che set interval cerchi le variabili da passare alla funzione nello 
scopo globale dello script e non nello scopo da cui è stata chiamata, ciò 
spiegherebbe perchè nel primo caso mi arriva un oggetto window mentre nel 
secondo non trova la variabile che intendo usare.
Adesso provo un'escamotage diverso, provo a passare l'ID numerico di 
setInterval e vedo se basta quello a stoppare il timer :)

 setInterval e vedo se basta quello a stoppare il timer :)
Piccola idiozia: non posso passargli l'ID numerico mentre lo creob :(
-- 
Gerry@work - Fan #1 di Yukino Miyazawa 
http://www.gerry.it/
 - 
http://spakkomatto.com/
 
Per contattarmi in privato usate il form: 
http://www.gerry.it/serve/mail/
La Fiesole - C2: COLPITA E AFFONDATA - We're coming!
La gente pensa che chiunque possa suonare la batteria nei Ramones. Quando 
arrivò, Clem chiese a Johnny quanti tempi doveva suonare. La risposta fu: 
veloce e più veloce. Dopo due settimane era fuori dal gruppo
<< NG corner>>
it.fan.musica.u2 corner -> 
http://members.xoom.it/ifmu2/
It.sport.calcio.fiorentina -> 
http://www.iscf.info/

 this.intervalHandler=setInterval("dhtm_appro(mySelfRef)",this.msec);
hai messo un "var" di troppo. Basta fare:
mySelfref = this;
oppure
window.mySelfref = this;
Gaetano

 window.mySelfref = this;
 
Il mio problema non è questo, è che una volta creata la referenza non c'è 
verso di passarla alla funzione richiamata periodicamente.
fa nulla, ristrutturerò tutto in diversa maniera.


se fai così:
window.mySelfref = this;
this.intervalHandler = setInterval("dhtm_appro()", this.msec);
e la funzione la definisci così:
function dhtm_appro()
{
   alert("reference = " + window.mySelfref);
}
Che cosa ottieni dall'alert?
Gaetano

 Che cosa ottieni dall'alert?
OK, ma se io ho più di un interval attivo allo stesso momento? :)
Lo so, forse voglio troppo... ;P
Comunque è un'idea, posso sempre aggiungere una proprietà al DIV su cui sto 
lavorando. Mi sembra si possa fare, no?

 setInterval e vedo se basta quello a stoppare il timer :)
Certo, basta l'ID del setInterval, ma non glielo puoi passare mentre lo 
crei, come hai gia' appurato. ;)
-- 
C'ya,
ZER0
  :. job profile - coder.gfxer.webDesigner
"when you eliminate the impossible, whatever remains, however 
improbable, must be the truth" (S.H.)

 la questione. :)
In realtà l'ho risolta :)
Era semplicemente un oggetto che muoveva o ridimensionava un div (tipica 
funzione per effetti dhtm).
L'oggetto posso instanziarlo diverse volte, il che significa poter 
gestire più DIV in movimento contemporaneamente.
la funzione che muove il layer (che non può essere il metodo di un 
oggetto, visto che non è previsto da setinterval) si dovrebbe preoccupare 
di stoppare il timer quando ha finito di lavorare sul DIV incriminato. Ma 
come faccio a farle capire quale timer stoppare?
Ho risolto mettendo il numero del timer nel DIV stesso, in una proprietà 
aggiuntiva.
Così quando la funzione ha finito sa dove andarsi a prendere il numero 
del timer da stoppare.
visto che mi avete aiutato posto il codice che ho sviluppato:
Testato e funzionante su Opera 7.x, Mozzilla e IE6 ^_^
function dhtm_appro_stop(intervalID){
	//stoppo l'interval don ID intervalID
	clearInterval(intervalID);
	}
function dhtm_appro(tgID,tgProp,treshold,step){
/* 
	FUNZIONE DI MOVIMENTO
	tgID = (string)id dell'oggetto da manipolare
	tgProp = (string)proprietà da manipolare
	treshold = (int) obbiettivo da raggiungere
	step = (int+) entità della modifica
	ferma l'oggetto di gestione del movimento quando ha finito
*/
	//setto temporaneamente newval
	var newVal='1px';	
	//ottengo la reference all'oggetto da modificare
	var objRef=document.getElementById(tgID);
 
	// inizializzo
	var actual = 0;
	var evalStr='';
 
	// ottengo il valore attuale con un eval
	evalStr='actual=objRef'+tgProp;
	eval(evalStr);
	//la interizzo
	actual=parseInt(actual);
	// calcolo qual'è la distanza assoluta fra la dimensione attuale e 
quella programmata
	var distance = Math.abs(actual-treshold);
	// se la distanza fra i due è minore od uguale allo step chiudo la 
faccenda
	if(distance<=step){
		//applico le modifiche con una eval
		evalStr='objRef' + tgProp + '=\'' + treshold +'px\'';
		eval(evalStr);
		//blocco il timer
		dhtm_appro_stop(objRef.dhtmTimer);
		//elimino il timer dall'oggetto
		objRef.dhtmTimer=0;
		//ritorno
		return;
		}
 
	//altrimenti cerco di avvicinarmi alla dimensione voluta
	// controllo se la dimensione attuale è più o meno di quella voluta
	if (actual<treshold){
		//se è minore aggiungo lo step
		newVal = (actual+step)+'px';
		}
	else{
		//se è maggiore tolgo lo step
		newVal = (actual-step)+'px';
		}
 
 
	//applico le modifiche con una eval
	evalStr='objRef' + tgProp + '=\'' + newVal +'\'';
	eval(evalStr);			
	}//fine dhtm_appro
/* #######################################################
   OGGETTO CHE GESTISCE IL MOVIMENTO
   ####################################################### */
 
function dhtm_appro_run(){
 
	//ottengo la reference all'oggetto su ciu sto lavorando.
	var objRef=document.getElementById(this.tgID);
	//controllo che non ci sia già un timer attivo
	if(objRef.dhtmTimer){
		//se c'è esco 
		return(0);
		}
 
	//creo la string di launch del timer
	var launchStr="dhtm_appro('"+this.tgID+"','" + this.tgProp + "'," + 
this.treshold + "," + this.step + ")";
	// creo e setto il timer
	objRef.dhtmTimer=setInterval(launchStr,this.msec);
	//annoto il timer
	this.dhtmTimer=objRef.dhtmTimer;
 
	//ritorno true
	return(1);
	}//fine
function dhtm_move_engine(tgID,tgProp,step,tgDim,msec){
/* 
	COSTRUTTORE DI CLASSE
	tgID = (stringa) id dell'oggetto da modificare
	tgProp = (stringa) proprietà da modificare
	step = (int+) entità dello step
	tgDim = (int) target da raggiungere
	msec = (int+) delay dell'intervallo
*/
	//stocca internamente le variabili
	this.tgID=tgID;
	this.tgProp=tgProp;
	this.step=step;
	this.treshold=tgDim;
	this.msec=msec;
	//segno che l'oggetto non è in running state
	this.running=0;
	//registro i metodi
	this.run=dhtm_appro_run;
	}
 
 
 
/* #######################################################
   ENGINE GENERALE DI RIDIMENSIONAMENTO
   ####################################################### */
function dhtm_set_step(step){
/* 
	SETTA LO STEP DA UTILIZZARE NELLA PROCEDURA
	step è un intero
	step = 0 => step=1
	step > 0 => setta lo step e ritorna lo step settato
	step < 0 => fa il modulo, risetta lo step e ritorna lo step settato
*/
	//controllo che si intero
	step=parseInt(step);
	//controllo che non sia negativa
	step=Math.abs(step);
	//controllo il valore di step
	if(step==0){
		this.step=1;		
		//se è 0 ritorno la variabile
		return(this.step);
	}
	else{
		//setto la variabile
		this.step=step;
		//la ritorno
		return(this.step);
	}
 
}//fine set_get_step
function dhtm_set_msec(msec){
/* 
	SETTA IL DELAY IN MSEC DELLA FUNZIONE DI RIDIMESIONAMENTO
	msec è un intero > 0
 
*/
	//controllo che sia intero positivo
	msec=Math.abs(parseInt(msec));
	//controllo il valore di step
	if(msec==0){
		this.msec=1;		
		//se è 0 ritorno la variabile
		return(this.msec);
	}
	else{
		//setto la variabile
		this.msec=msec;
		//la ritorno
		return(this.msec);
	}
 
}//fine set_get_step
function dhtm_movew(objTargId,wTarg){
/*
	RESIZE ORIZZONTALE
	muove di step px otargid
	otargid = ID del target
	wtarg = width target
*/
	//controllo che la wTarg siaintero positivo
	wTarg=Math.abs(parseInt(wTarg));
 
	//objTar.style.width=wTarg+'px';
	//return;
 
	//creo l'oggetto di gestione del movimento
	mover= new dhtm_move_engine
(objTargId,'.style.width',this.step,wTarg,this.msec);
	// lo avvio
	mover.run();
	//quando ha finito lo distruggo
	delete mover;
 
 
}//fine dhtm_movew
function dhtm_move_custom(objTargId,objTargProp,dimTarg){
/*
	MODIFICA DI UNA DIMENSIONE CUSTOM
	muove di step px otargid
	objTargId = (string)ID del target
	objTargProp = (string)proprietà target
	dimTarg = (int)valore finale
*/
	//controllo che la dimTarg sia intera
	dimTarg=parseInt(dimTarg);
 
	//creo l'oggetto di gestione del movimento
	mover= new dhtm_move_engine
(objTargId,objTargProp,this.step,dimTarg,this.msec);
	// lo avvio
	mover.run();
	//quando ha finito lo distruggo
	delete mover;
 
}//fine dhtm_movew
function dhtm_resize(step,msec){
/* 
	COSTRUTTORE DI CLASSE
	step è un intero
	step = 0 => step diventa 1
	step > 0 => setta lo step
	step < 0 => fa il modulo e risetta lo step.
*/
 
	//setto provvisoriamente step e msec
	this.step=1;
	this.msec=1;
	//attacco le funzioni di settaggio
	this.set_step=dhtm_set_step;
	this.set_msec=dhtm_set_msec;
	//attacco le funzioni di moving
	this.movew=dhtm_movew;
	this.moveCustom=dhtm_move_custom;
 
	//setto stem e msec secondo i valori attuali
	this.set_step(step);
	this.set_msec(msec);
}// fine dhtm_resize (costruttore)
//function dhtm_increase

 Testato e funzionante su Opera 7.x, Mozzilla e IE6 ^_^
[cut]
E' troppa roba, non ho modo di leggerla tutta, purtroppo. :) Cmq io 
proverei a cambiare approccio. Tenere queste sorgenti da una parte, o 
tentare di migliorarne il codice/filosofia. Alla peggio, ritorni su 
questi.
-- 
C'ya,
ZER0
  :. job profile - coder.gfxer.webDesigner
"When you have eliminated the impossible, whatever remains,
however improbable, must be the truth." (S.H.)

 questi.
Se mi capiterà di doverli usare <grin> ci ritornerò sopra.
Però c'è una soluzione semplice ed efficace. Affanc... le transizioni e 
stiamo tutti più tranquilli :PPPP

 stiamo tutti più tranquilli :PPPP
Ahaha.. beh, come vuoi.. :D
