Armetiz

Mise en situation :
deux animations A.SWF, B.SWF
La taille des scènes est de 1024×764 pour A, et 800×600 pour B.

A charge B, et redimensionne B pour le mettre dans la liste d’affichage de A.

Le problème qui peut ce poser est le suivant.
La zone d’affichage intéressante de B est celle de sa scène.
B est construit sur une base de 800×600, et les graphistes placent des éléments graphiques qui font parfois bien plus de 800×600. Lorsqu’on lit B dans le player en stand alone, on ne voit que les 800×600 pixel de la scène, et les éléments qui sont à l’extérieur ne sont pas visibles (hormis si l’on redimensionne la fenêtre à la main).

On va maintenant charger B dans A

1
2
3
4
5
6
7
8

var loaderB : Loader = new Loader ();
loaderB.contentLoaderInfo.addEventListener (Event.COMPLETE, onComplete);
loaderB.load (new URLRequest ("B.swf"));
 
function onComplete (ev : Event) : void
{
    trace (ev.target.content.width + " " + ev.target.content.height);
}

A première vu, on s’attend à obtenir nos 800×600 et faire un règle de trois pour obtenir la taille adéquate.

Loader.content
Contient l’objet d’affichage racine du fichier SWF ou du fichier d’image (JPG, PNG ou GIF) qui a été chargé à l’aide de la méthode load() ou loadBytes().

La propriété Loader.content nous retournera donc l’ensemble des éléments graphiques de notre fichier B.swf, et Loader.content.width ne retournera pas 800, mais la largeur de l’ensemble des éléments sur la scène de B.

Pour pouvoir récupérer la taille de la scène de B, il faut regarder les propriétés du fichier SWF, et nous allons utiliser le LoaderInfo associé à notre Loader

Loader.contentLoaderInfo
La classe LoaderInfo fournit des informations relatives à un fichier SWF ou à un fichier d’image (JPEG, GIF ou PNG) chargé. Les objets LoaderInfo sont disponibles pour n’importe quel objet d’affichage. Les informations indiquées comprennent la progression du chargement, les URL de l’objet Loader et du contenu chargé, le nombre total d’octets du média, ainsi que la hauteur et la largeur nominales de ce dernier.

Et voila, nous savons maintenant où trouver la taille de la scène.

1
2
3
4
5
6
7
8

var loaderB : Loader = new Loader ();
loaderB.contentLoaderInfo.addEventListener (Event.COMPLETE, onComplete);
loaderB.load (new URLRequest ("B.swf"));
 
function onComplete (ev : Event) : void
{
    trace (ev.target.contentLoaderInfo.width + " " + ev.target.contentLoaderInfo.height);
}

A noter, sur le forum MediaBox, Dada m’a fait remarquer tout justement, que la propriété DisplayObject.root.loaderInfo renvoyait la même référence que Loader.contentLoaderInfo.

A votre avis, quel sera le résultat de ce bout de code ?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

function un () : Boolean
{
        trace ("un");
        return false;
}
 
function deux () : Boolean
{
        trace ("deux");
        return true;
}
 
if (un() && deux ())
        trace ("trois");
 
//Affiche : un

Que peut-on retenir de cela ?
Simplement, lors de l’évaluation de deux conditions avec un ET, si l’on tombe sur une condition fausse, les autres ne sont pas évaluées.
Si vous ne voyez pas l’intérêt, je vais vous donner un exemple tout simple.

1
2
3
4
5
6
7

for (var i : int = 0 ; i < numChildren ; i++)
{
        if ((getChildAt (i) as MovieClip).hasOwnProperty)
        {
                trace ("ok");
        }
}

Ce bout de code peut nous donner une erreur à l’exécution dans le cas ou getChildAt (i) ne retourne pas un objet qui soit de type MovieClip.
Même si “as” retourne NULL lorsque l’objet ne peut être caster, contrairement au cast explicite qui génère une erreur, NULL n’ayant aucune propriété vous allez avoir une erreur “Vous essayer d’atteindre une propriété d’un objet de référence null.”

Il faut donc vérifier le type de l’objet avant de l’utiliser.

1
2
3
4
5
6
7
8
9
10

for (var i : int = 0 ; i < numChildren ; i++)
{
        if (getChildAt (i) is MovieClip)
        {
                if ((getChildAt (i) as MovieClip).hasOwnProperty)
                {
                        trace ("ok");
                }
        }
}

Ici, pour que l’on puisse utiliser hasOwnProperty, il faut que notre objet soit de type MovieClip. Mais, avouer que cela ne fait pas jolie, plus on peut limiter le nombre de boucles imbriquées, mieux c’est.

Voici comment mettre en pratique la démonstration du début pour notre cas.

1
2
3
4
5
6
7

for (var i : int = 0 ; i < numChildren ; i++)
{
        if ((getChildAt (i) is MovieClip) && ((getChildAt (i) as MovieClip).hasOwnProperty)
        {
                trace ("ok");
        }
}

Je ne vous ferai pas l’affront de vous dire que le poids du code source sera allégé, mais cela peut augmenter la facilité de lecture.

De la même manière, pour l’étude d’un OU lorsque l’on rencontre une condition “vrai”, on ne regarde pas les autres valeurs.

Démonstration :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

function un () : Boolean
{
        trace ("un");
        return true;
}
 
function deux () : Boolean
{
        trace ("deux");
        return false;
}
 
if (un () || deux ())
        trace ("trois");
 
//Affiche "un" "trois"

Pour tout vous dire, je n’ai pas d’exemple concret en tête… Mais bon, vous en trouverez surement un