Erreur interne Firefox "Component returned failure code"

Version imprimable

Bonjour à tous,
S'il vous plait j'ai une class dojo :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
dojo.declare(
            "maClass",
            dijit._Widget,
            {
                 gabarit: null,
                 constructor: function (gabarit) {
                    if (gabarit == "[object HTMLDocument]") {
                        this.gabarit = gabarit;
                    }
                    console.log(this.gabarit);
 
                },

je cree un objet Domdocument par 'document.implementation.createDocument' puis je le pass en parametre au constructeur de maClass, alors il m'affiche la console.log de thi.gabarit que c'est un domDocument puis il m'affiche cette erreur :

Code:

1
2
 
uncaught exception: [Exception... "Component returned failure code: 0x80040111 (NS_ERROR_NOT_AVAILABLE) [nsIDOMNSDocument.activeElement]" nsresult: "0x80040111 (NS_ERROR_NOT_AVAILABLE)" location: "JS frame :: http://localhost/MyWorkspace/Test/dojo/dojo/dojo.js :: anonymous :: line 16" data: no]

d'ou vient cette erreur??
et Merci

15/12/2009, 20h41
emmanuel.remy

Salut,

Passe le code complet de ton composant qu'on puisse tester stp .

ERE

merci emmanuel.remy, voila le code :

Code:

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
//la creation et le remplissage du document
var doctype = document.implementation.createDocumentType("html",
            "-//W3C//DTD XHTML 1.0 Transitional//EN",
            "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd");
    var monDocument = document.implementation.createDocument("http://www.w3.org/1999/xhtml",
            "html", doctype);
    var monTagHtml = monDocument.documentElement;
    monBody = monDocument.createElement("body");
    monTagHtml.appendChild(monBody);
    var frontBody = monDocument.createElement("div");
    frontBody.id = "frontBody";
    frontBody.setAttribute('class','frontBody');
    monBody.appendChild(frontBody);
    var i = 1;
    while (i < 5) {
    	maDiv = monDocument.createElement("div");
    	maDiv.id = "zone-"+i;
    	maDiv.setAttribute('class','zone');
    	frontBody.appendChild(maDiv);
    	var bloc = monDocument.createElement("div");
    	bloc.id = 'bloc-'+i;
    	bloc.setAttribute('class','bloc');
    	maDiv.appendChild(bloc);
    	i++;
    }

et voila ma classe

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
dojo.declare(
            "maClass",
            dijit._Widget,
            {
 
                gabarit: null,
 
                constructor: function (gabarit) {
                    if (gabarit == "[object HTMLDocument]") {
                        this.gabarit = gabarit;
                    }
                    console.log('gabarit ',this.gabarit);
                    console.log('fin');
                },
                 ....

et voila l'instanciation de maClass

Code:

1
2
var zineb = new maClass(monDocument);
	console.log('maClass a ete instancier');

alors qu'il m'affiche les console.log du constructeur,et juste apres le constructeur il affiche l'erreur ci-dessus (alors que la console.log('maClass a ete instancier')ne s'affiche pas)?
et Merci

21/12/2009, 17h14
Zineb1987_UNI

apres des petites implementation dans le constructeur voila la nouvelle erreur afficher :

Code:

uncaught exception: [Exception... "Component returned failure code: 0x80004001 (NS_ERROR_NOT_IMPLEMENTED) [nsIDOM3Document.domConfig]" nsresult: "0x80004001 (NS_ERROR_NOT_IMPLEMENTED)" location: "JS frame :: http://localhost/MyWorkspace/Test/dojo/dojo/dojo.js :: anonymous :: line 16" data: no]

d'ou vient ?
et Merci
21/12/2009, 18h04
emmanuel.remy

Aucune idée... :cry:

Peut-être ouvrir un ticket chez Dojo.

ERE
21/12/2009, 18h16
Zineb1987_UNI

:calin: emmanuel.remy,d'accord de toute façon merci bien, je continue la recherche...et si je trouve la solution je la signle ici ;)
11/01/2010, 18h40
Zineb1987_UNI

bon c'est Résolu,le problème était :
puisque maClass hérite du dijit._widget alors le constructeur doit respecter son pattern, et comme tout les widget se crée de cette façon :

Code:

constructor(args, domNode)

et merci une autre fois emmanuel.remy
12/01/2010, 15h15
emmanuel.remy

Salut,

Par défaut Dojo appelle le constructeur du parent.
Mais si tu le fais toi alors il laisse tomber. Je pense que u peux donc garder la signature initiale pour ton constructeur et appeler toi-même le constructeur parent (this.inherited...).

ERE
13/01/2010, 09h47
Zineb1987_UNI
bon j'ai gardé la signature initiale de mon constructeur, et j'ai ajouté this.inherited(arguments),comme ca
Code:

1 2 3 4 constructor: function (doc, zones, blocs, liens) { console.log('(____@__--_`| Zineb Builder |`_--__@____)'); this.inherited(arguments); }
et voila l'erreur qu'il donne :

Code:

uncaught exception: GabaritBuilder: inherited method "undefined" mismatch
13/01/2010, 09h59
vermine
Bonjour,

Ce ne serait pas plutôt:
Code:

1 2 this.inherited("leConstructeur", arguments);
Où leConstructeur est la méthode que vous désirez appeler. Ou peut-être this.
13/01/2010, 11h26
Zineb1987_UNI

bon quand j'ai mis :

Code:

this.inherited("constructor", arguments);

j'ai la même erreur

Code:

uncaught exception: GabaritBuilder: inherited method "constructor" mismatch

et si je met:

Code:

this.inherited(this, arguments);

j'obtiens l'erreur :

Code:

_f2.callee is undefined

et Merci.

Salut,

Je me rends compte que j'ai écrit un peu vite une bêtise la dernière fois: en effet par défaut le constructor appelle le (les) constructeur(s) de(des) classe(s) parente(s). Donc ici le this.inherited(argument) ne sert à rien :roll: . Ci-dessous un exemple vite fait du souci rencontré et de l'impact notamment dans le cadre de l'héritage multiple:

Code:

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <script type="text/javascript" src="/dojotoolkit/dojo/dojo.js"></script>
 
        <script type="text/javascript">
        djConfig="parseOnLoad: true, isDebug: true";
 
        dojo.declare(
                "Personne",
                null,
                {
			constructor: function(nom,prenom) {
				this.nom=nom;
				this.prenom=prenom;
				}
                }
        );
 
        dojo.declare(
                "Footballeur",
                Personne,
                {
			constructor: function(nom,prenom,equipe) {
				this.equipe = equipe;
				}
                }
        );
 
        dojo.declare(
                "Avatar",
                null,
                {
			constructor: function(energie) {
				this.energie=energie;
				},
                }
        );
 
        dojo.declare(
                "Personnage",
                [Personne, Avatar],
                {
                	constructor: function(nom, prenom, energie, monde) {
                		this.monde = monde;
                	}
                }
                );
 
 
        dojo.addOnLoad(
    	    function(){
	    	//création d'une personne avec nom et prenom
	    	var canto = new Personne("Cantona","Eric");
		console.log(canto);
		//Via l'héritage, on ajoute l'équipe
		var canto2 = new Footballeur("Cantona","Eric","Manchester United");
		console.log(canto2);
		//et si on ne passa pas tous les partamètres attendus ? Pas de souci mais manque de données...
		var canto3 = new Footballeur("Cantona");
		console.log(canto3);
 
		//souci!!  car l'héritage multiple va appeler les constructeurs dans l'ordre
		//d'heritage, en passant à chaque fois les mêmes arguments
		//donc Avatar qui attend "energie" comme seul paramètre de son constructeur
		//va en fait recevoir "Cantona". Aïe !!
		var canto4 = new Personnage("Cantona","Eric",123, "Football");
		console.log(canto4);
    	    });
    </script>
  </head>
 
  <body>
		<p>Hello world !</p>
  </body>
</html>

Une des solutions couramment utilisée est d'utiliser un objet comme paramètre du constructeur. Donc voilà ce que cela pourrait donner, vous constaterez que l'héritage multiple fonctionne alors:

Code:

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <script type="text/javascript" src="/dojotoolkit/dojo/dojo.js"></script>
 
        <script type="text/javascript">
        djConfig="parseOnLoad: true, isDebug: true";
 
        dojo.declare(
                "Personne",
                null,
		{
			nom: "",
			prenom : "",
			constructor: function(args /*objet {nom: XXXX, prenom: XXXX} */) {
				args = args || {};
				dojo.mixin(this, args);
				//if (args.nom) { ... }
				/* ou 
				this.nom = args.nom;
				this.prenom = args.prenom;
				*/
				},
                }
        );
 
        dojo.declare(
                "Footballeur",
                Personne,
                {
			constructor: function(args /* objet { nom: XXXX, prenom: XXXX, equipe: XXXX } */) {
				this.equipe = args.equipe;
				},
                }
        );
 
        dojo.declare(
                "Avatar",
                null,
                {
			constructor: function(args /* { energie: XXX } */) {
				this.energie = args.energie;
				},
                }
        );
 
        dojo.declare(
                "Personnage",
                [Personne, Avatar],
                {
			constructor: function(args /*objet { nom : XXXX, prenom:XXXX, energie:XXXXX, monde:XXXXX } */) {
                		this.monde = args.monde;
                	}
                }
                );
 
 
        dojo.addOnLoad(
    	    function(){
	    	//création d'une personne avec nom et prenom
	    	var canto = new Personne({nom:"Cantona",prenom:"Eric"});
		console.log(canto);
		//Via l'héritage, on ajoute l'équipe
		var canto2 = new Footballeur({nom:"Cantona",prenom:"Eric", equipe:"Manchester United"});
		console.log(canto2);
 
		//finalement un Personnage correct
		var canto4 = new Personnage({nom:"Cantona",prenom:"Eric", monde:"Football", energie:123});
		console.log(canto4);
    	    });
    </script>
  </head>
 
  <body>
		<p>Hello world !</p>
  </body>
</html>

A noter aussi, mais moins utilisé, que le constructeur est en fait la seconde fonction appelée lors de la création de l'instance. Préalablement, Dojo appelle la fonction preamble qui reçoit les paramètres d'instanciation et qui peut fournir en retour (return) de nouveaux paramètres qui seront eux envoyer au constructeur des classes Parentes. Cela peut être LA solution si on veut se passer des objets commes paramètres, sauf dans le cas de l'héritage multiple. Dans ton cas, Zineb1987_UNI, c'est parfaitement adapté:

Code:

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
<html>
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <script type="text/javascript" src="/dojotoolkit/dojo/dojo.js"></script>
 
        <script type="text/javascript">
        djConfig="parseOnLoad: true, isDebug: true";
 
        dojo.declare(
                "Personne",
                null,
                {
			constructor: function(nom,prenom) {
				this.nom=nom;
				this.prenom=prenom;
				},
                }
        );
 
        dojo.declare(
                "Footballeur",
                Personne,
                {
			constructor: function(nom,prenom,equipe) {
				this.equipe = equipe;
				},
                }
        );
 
 
        dojo.declare(
                "FootballeurManchester",
                Footballeur,
                {
			//la fonction appelée AVANT le constructeur donc
			//même si FootballeurManchester herite de Footballeur
			//on va pouvoir spécifier notre propre constructeur sans entrer en conflit
			preamble: function(nom,prenom) {
				//ce tableau est envoyé aux contructeurs parents, donc Footballeur
				return [nom, prenom, "Manchester"];	
			},
 
			//pas la même signature que Footballeur (qui attend le nom de l'équipe en 3eme position) !
			constructor: function(nom,prenom,numero) {
				this.numero = numero;
				},
                }
	);
 
        dojo.addOnLoad(
    	    function(){
	    	//création d'une personne avec nom et prenom
	    	var canto = new Personne("Cantona","Eric");
		console.log(canto);
		//Via l'héritage, on ajoute l'équipe
		var canto2 = new Footballeur("Cantona","Eric","Manchester United");
		console.log(canto2);
		//
		var canto4 = new FootballeurManchester("Cantona","Eric",7);
		console.log(canto4);
    	    });
    </script>
  </head>
 
  <body>
		<p>Hello world !</p>
  </body>
</html>

En espérant que cela aura éclairé un peu les choses,

Bon dev,

ERE