[AS3] addChild mi porta in primo piano... come mai?

[cleverboy]

Ciao

con un po' di ispirazione e un briciolo di copia incolla ho fatto una fotogallery in as3.

Vorrei un chiarimento su un piccolo stralcio di codice:

private function onClick(e:MouseEvent):void {
			var mc:MovieClip = MovieClip(e.currentTarget);
			if(inFocus == null){
				scaleUp(mc);
			}
...
... 
}

private function scaleUp(mc:MovieClip):void {
			con.addChild(mc);
			TweenLite.to(mc,0.7,{
						 scaleX:3,
						 scaleY:3, 
						 x:495 - 3*Math.ceil(mc.width/2), 
						 y:250 - 3*Math.ceil(mc.height/2), 
						 ease:Expo.easeInOut
			});
			inFocus = mc;
}

Praticamente qui allargo un'immagine portandola in primo piano...ed è qui che mi sorge una domanda:
se io elimino la riga con.addChild(mc) la funzione fa la stessa cosa ma l'oggetto ingrandito spesso rimane parzialmente coperto dai thumbs successivi (che ovviamente hanno una depth superiore).
Con quella riga invece mi porta l'oggetto in primo piano.

Il mio quesito è: come mai anziché creare un nuovo movieclip, addChild mi porta quello in primo piano? scaleUp riceve come parametro un riferimento al movieclip da allargare, facendo addChild non dovrebbe crearsi un errore tipo "movieclip già presente... cosa stai facendo!!"?

Grazie

PS: qualcuno sa come si fa un duplicateMovieClip in as3? Mi servirebbe per fare un effetto riflesso sotto le immagini... o avete altri metodi?

Thanx

[and80]

Il metodo addChild aggiunge dinamicamente un oggetto di visualizzazione ad un contenitore, impostandone la profondità più alta rispetto agli altri oggetti contenuti, un po' come si faceva in AS2 sfruttando il metodo getNextHighestDepth().
In AS3 però ogni qualvolta un oggetto viene richiamato da questo metodo, la sua visualizzazione si "sposta" verso un altro elemento, o se viene richiamato nello stesso oggetto, sposta la sua profondità più in alto rispetto agli altri oggetti (rimuovendosi dalla sua vecchia posizione).

[and80]

PS: qualcuno sa come si fa un duplicateMovieClip in as3? Mi servirebbe per fare un effetto riflesso sotto le immagini... o avete altri metodi?

Ci sono parecchi codici in giro in grado di generare in maniera automatica un riflesso, mentre per il duplicateMovieClip il discorso è un po' più lungo e non è adatto allo scopo.

La mia proposta per il riflesso è questa classe da copiare in un file da salvare come Mirror.as e da mettere nella stessa cartella in cui la vuoi usare:

/**
 * @class Mirror
 *         
 * ----------------------------------------------------------------------------------------------------------
 * @file        Mirror.as
 * @size         4.686 byte
 * @version    1.0.1 - ActionScript 3.0 compliance
 * @author        Andrea Milillo
 * @date        22/01/2009
 * @modify        01/06/2009 11.02
 * @site        [url]http://www.v2online.it[/url]
 */

 /**
    Version note:
 */
 
/*
Licensed under the MIT License

Copyright (c) 2009 Andrea Milillo

Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use,
copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following
conditions:

The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
*/

package {
    import flash.display.*;
    import flash.geom.*;
    public class Mirror extends Sprite {
        private var __t:DisplayObject;
        private var __d:Number;
        private var __o:Number;
        private var __u:Number;
        private var __b:Bitmap;
        private var __g:GradientShape;
        private var __v:Array;
        /** 
        * @method    Mirror Mirror ([target:DisplayObject=null, distance:Number=0, opacity:Number=1, uncovered:Number=1])
        * @param    target:DisplayObject    Opzionale - l'oggetto target da cui ricavare lo specchio
        * @param    distance:Number         Opzionale - la distanza verticale tra il clip originale e il suo specchio
        * @param    opacity:Number          Opzionale - l'opacità in un valore da 0 a 1, della maschera che copre lo specchio
        * @param    uncovered:Number        Opzionale - la parte scoperta in un valore da 0 a 1, della maschera che copre lo specchio
        */
        public function Mirror (t:DisplayObject=null, d:Number=0, o:Number=1, u:Number=1) {
            __t = t;
            __d = d;
            __o = o;
            __u = u;
            __init__();
        }
        private function __init__ () {
            if(__t != null) {
                __b = new Bitmap();
                __g = new GradientShape(__t.width, __t.height*__u, __o);
                __b.cacheAsBitmap = __g.cacheAsBitmap = true;
                __b.mask = __g;
                __v = [];
                addChild(__b);
                addChild(__g);
                __v.push(new BitmapData(__t.width, __t.height, true, 0));
                __v.push(new Matrix());
                __v.push(__t.getRect(__t));
                __v[1].translate(-__v[2].x, -(__v[2].height+__v[2].y));
                __v[1].scale(1, -1);
                __v[0].draw(__t, __v[1]);
                __b.bitmapData = __v[0];
                __b.x = __g.x = __v[2].x;
                __b.y = __g.y = __v[2].y;
                x = __t.x;
                y = __t.y+__t.height+__d;
            }
        }
        public function refresh () {
            try {
                while(numChildren > 0) {
                    removeChildAt(numChildren-1);
                }
                __init__();
            } catch(e) {}
        }
        public function set target (t:DisplayObject) {
            __t = t;
        }
        public function get target ():DisplayObject {
            return __t;
        }
        public function set distance (d:Number) {
            __d = d;
        }
        public function get distance ():Number {
            return __d;
        }
        public function set opacity (o:Number) {
            __o = o;
        }
        public function get opacity ():Number {
            return __o;
        }
        public function set uncovered (u:Number) {
            __u = u;
        }
        public function get uncovered ():Number {
            return __u;
        }
    }
}
import flash.display.GradientType;
import flash.display.Shape;
import flash.display.SpreadMethod;
import flash.geom.Matrix;
internal class GradientShape extends Shape {
    public function GradientShape (w:Number, h:Number, a:Number) {
        var fillType:String = GradientType.LINEAR;
        var colors:Array = [0, 0];
        var alphas:Array = [a, 0];
        var ratios:Array = [0, 255];
        var matr:Matrix = new Matrix();
        matr.createGradientBox(w, h, 90/180*Math.PI, 0, 0);
        var spreadMethod:String = SpreadMethod.PAD;
        graphics.beginGradientFill(fillType,colors,alphas,ratios,matr,spreadMethod);
        graphics.drawRect(0, 0, w, h);
        graphics.endFill();
    }
} 

Di base si usa così:

var mirror:Mirror = new Mirror(oggetto_da_riflettere);
oggetto_da_riflettere.parent.addChild(mirror); 

[cleverboy]

Grazie mille. Davvero utile
L'ho appena provato e, salvo aggiustamenti mi pare molto carino.

Grazie davvero... ora mi studio anche il codice per capire come funziona

[and80]

E' abbastanza semplice, si crea una copia bitmap dell'oggetto che si vuole specchiare e gli si applica una maschera in trasparenza in modo da creare la sfumatura, poi la si gira e la si sposta usando la classe Matrix per farla coincidere con l'oggetto da specchiare.