Discussion :

[hush]

Salut,

J'utilise plusieurs fonctions dans une fonction principale, principalement pour gérer des effets, attendre des réponses AJAX, etc...
Le problème étant que tout le traitement se fait à travers l'ensemble de ces fonctions. Par conséquent, la valeur de retour de la fonction principale en dépend.

Ce que je voudrais c'est "synchroniser" la valeur de retour après l'appel de chaque fonction nécessaire à sa définition.

Si quelqu'un a une idée de comment faire ce genre de choses...

[marcha]

Salut,

Un petit bout de code pour illustrer ?

[hush]

Biensûr

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
// Il s'agit d'une gestion de rubriques à travers un composant 'arbre'
// Le tout geré en drag and drop:
tree.enableDragAndDrop(1);
tree.setDragHandler(treeDrop); // Fonction pour laquelle je veux une valeur de retour bien précise

// La fonction elle même:
function treeDrop(srcID, dstID) {
		
	state_span.innerHTML = 'Déplacement de la catégorie...';
		
	Effect.Appear(state_div, {
		duration: 1,
		afterFinish: function () {
			new Ajax.Request('AJAX/PHP/categories.move.php', {
				method: 'POST',
				parameters: {src_id: srcID, dest_id: dstID},
				
				onSuccess: function(transport) {
					Effect.Fade(state_div, {
						duration: 1,
						afterFinish: function () {
							json = eval(transport.getResponseHeader('X-JSON'));
							
							if (typeof(json.error) != 'undefined') {
								widget_show_error(json.error);
								tree.moveItem(srcID, dstID);
								// Ici j'aimerais renvoyer false
							}
							else {
								widget_remove_errors();
								// Ici j'aimerais renvoyer true
							}
						}
					});
				}
			});
		}
	});
	return true;
}

[marcha]

Salut,

Ta fonction principale va se terminer bien avant même que les autres ne
sont appellées. Par exemple, la fonction anonyme du onSuccess
de la requête sera appellée lorsque le serveur aura daigné répondre.

Ta fonction principale sera terminée et il est trop tard pour qu'elle retourne
qqch. Je crois que si tu implémente un mécanisme d'attente tu risque de
bloquer ton interface utilisateur durant l'attente.

Je pense qu'il te faut appeler une callback lorsque t'on traitement est terminé.

Si je t'ai bien compris tu envisages ton code ainsi:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
function evenement_utilisateur() {
  if(treeDrop(...)) {
     //... faire qqch quand c'est ok
  } else {
     //... faire qqch quand c'est pas ok
  }
}

Je pense qu'il faut le penser ainsi:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
function toutestok() {
   //... faire qqch quand c'est ok
}
function pasok() {
   //... faire qqch quand c'est pas ok
}
function evenement_utilisateur() {
   treeDrop(..., pasok, toutestok);
}

pasok et toutestok sont des références à des fonctions callback que tu
appelles là où tu pensais mettre ton return true, ou return false

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
// La fonction elle même:
function treeDrop(srcID, dstID, ok_callback, pasok_callback) {
 
...
if (typeof(json.error) != 'undefined') {
    widget_show_error(json.error);
    tree.moveItem(srcID, dstID);
    // Ici j'aimerais renvoyer false
    pasok_callback();
}
else {
	widget_remove_errors();
	// Ici j'aimerais renvoyer true
    ok_callback();
}

quand tu appelles treeDrop tu peux aussi utiliser des fonctions anonymes
pour gérer la réussite et l'échec

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
treeDrop(..., function() { /* ok */ }, function() { /* pas ok */ } );

en espérant avoir bien compris ta question :-)

[hush]

Tout d'abord merci beaucoup pour cette réponse très bien détaillée marcha.

J'ai essayé de suivre ton raisonnement, tu as très bien cerné le problème, par contre je ne pense pas que la solution fonctionne.

Je m'explique:

treeDrop est elle même une fonction de callback. Sa valeur de retour va déterminer l'action à appliquer après son appel.
Si je fais comme tu viens de l'expliquer, le problème restera le même, la valeur de retour sera envoyée avant le traitement de la requête et même en appelant une fonction de callback, il sera trop tard.
Il faudrait que je puisse mettre en attente la fonction jusqu'à la fin du traitement.. Mais je ne vois absolument pas comment faire ça.

Peut-être créer un évènement, qu'en penses-tu ?

[marcha]

Ok :-) sorry j'avais pas fait attention.

Est-ce que tu peux me dire l'objet tree que tu utilises ?
J'ai trouvé ceci http://www.scbr.com/docs/products/dh...ee/index.shtml
c'est celui là ?