Duda Evento en AS3

Hola quisiera saber si existe algun evento para detectar cuando un sprite o un moveclip cambie de tamaño? Gracias.

NO, no lo hay. Lo que ocurre es que se puede cambiar el tamaño de un Sprite de dos modos
1.-Poniendo nosotros el valor. Luego, sabemos exactamente cuando ocurre
2.-Mediante alguna función "Tween". Estas funciones suelen tener asociada una función, o podemos añadir un listener al cambio de la propiedad

en flex existen eventos personalizados , quizas en flash tambien se pueden crear o se puede??

Hola, primero que nada muchas gracias por las respuestas, pero ¿no se si puedan explicarme como hacer un listener al cambio de una propiedad? Saludos

Como ha dicho Eliseo2, el tamaño lo cambias tu, ya sea manualmente o mediante un Tween.

Por lo tanto, en el momento que hagas el cambio de tamaño, puedes dispachar un event y capturarlo, asi sabes cuando cambia. También puedes llamar a una función normal y corriente en cuanto cambie de tamaño, no se si me he explicado bien

ur! escribió:

hola, gracias por la respuesta, pero lo que pasa es que necesito tener un sprite q contendrá cualquier tipo de contenido ya sea texo, imágenes, shapes, u otros sprites etc etc. dentro de el, y su contenido se cargara dinamicamente y el tamaño del sprite aumentaría y disminuiría dependiendo de todos los objetos que estén dentro de el, y pues se le podran agregar objetos de cualquier forma, asi que yo creo que necesito hacer un listener a las propiedades del sprite ¿alguien que pueda ayudarme en eso ? saludos.

Dije muy rápido que no se podía, y no es cierto.

La idea es tener en dos variables "ancho" y "alto" el width y height del sprite.
Cuando añadimos algo dentro de él, comprobamos si ancho!=width o alto!=height. Caso de que sea así es que ha cambiado de tamaño.

Se puede hacer en la película principal directamente sin necesidad de dispatchar un evento

Código ActionScript :

var content:SpriteContent=new Spritecontent()
var alto:Number;
var ancho:Number;

//una vez añadido lo que sea, un simple "if"
if (alto!=content.width || ancho!=content.height){
     alto=content.width
     ancho=content.height
     trace("Ha cambiado de tamaño")
}

Vamos a hacerlo más compacto. Vamos ha hacer una Clase que extienda de Sprite

Código ActionScript :

package{
public class SpriteContent extends Sprite{
   private var alto:Number;
   private var ancho:Number;
   public static const CHANGE_TAMANO:String = "Cambio_tamano"; 
    
   public function SpriteContent(){
   }
   public function comprobarTamano():void{
          if (ancho!=width || alto!=height){
                 dispatchEvent(new Event(CHANGE_TAMANO))
                 ancho=width
                 alto=height
          }
    }
}
}

Así, nuestra película principal sería algo como

Código ActionScript :

var content:SpriteContent=new Spritecontent()
content.addEventListener(CHANGE_TAMANO,cambioTamano)
function cambioTamano(e:Event){
            trace(e.target.width+":"+e.target.height)
}
//en algún momento
//si tenemos un MC, p.e.
var mc:MovieClip=new MovieClip()
mc.graphics.lineStyle (1,0x000000,1);
mc.graphics.beginFill (0x00ff00,.5);
mc.graphics.drawRect (0, 0, 50, 50);

//cuando añadimos un MC
content.addChild(mc)
//llamamos al método comprobarTamano
content.comprobarTamano()

Vale, valos a darle una "vuelta de tuerca", esto es, sobre-escribir el método "addChild" -también deberíamos sobre-escribir el addchildAt- y los "setters" de width y height, scaleX y scaleY

Código ActionScript :

package { 
   import flash.display.Sprite;
   import flash.display.DisplayObject;
   import flash.events.Event;
   
   public class SpriteContent extends Sprite { 
      private var alto:Number; 
      private var ancho:Number; 
      public static const CHANGE_TAMANO:String = "Cambio_tamano";  
     
      public function SpriteContent(){ 
      } 
      public override function addChild(child:DisplayObject):DisplayObject { 
         var mc:DisplayObject = super.addChild(child); 
         comprobarTamano(); 
         return mc; 
      } 
   
      public override  function set width(value:Number):void 
      {
         super.width = value;
         comprobarTamano(); 
      }         
   
      public override  function set scaleX(value:Number):void 
      {
         super.scaleX = value;
         comprobarTamano(); 
      }
      public override  function set scaleY(value:Number):void 
      {
         super.scaleY = value;
         comprobarTamano(); 
      }
      public override  function set rotate(value:Number):void 
      {
         super.rotate= value;
         comprobarTamano(); 
      }
      private function comprobarTamano():void{ 
          if (ancho!=width || alto!=height){ 
                 dispatchEvent(new Event(CHANGE_TAMANO)) 
                 ancho=width 
                 alto=height 
          } 
      } 
   }    
}

Así, siempre comprobará el tamaño cuando hagamos un addChild o cambiemos el tamaño.
¡OJO!, si movemos algo en el INTERIOR del "content" No "dispatchará" el evento. La solución que le veo es hacer el "método" "comprobarTamano()" public y llamar en ese caso al método después de mover el objeto

Hola, muchas gracias por la respuesta, pense que ya no me habian respondido por que no me llego aviso a mi correo, pero en fin, muchisimas gracias, probare con eso. Saludos

Eliseo, me pareció buenísimo como reescribiste el método addChild, de hecho lo voy a probar a ver como anda, me hizo aprender algo más y ver lo flexible q es el laburar con clases. Tengo una duda respecto a esto. El hecho q sesobreescriba el método addChild hará q en esa aplicación cada vez q use addChild llamará a la nueva función de comprobar tamaño, esto en el caso q sea un programa largo por ej. un juego con muchos objetos no hará q corra más lento el player o su influencia sería ínfima???
Gracias por tus ganas de transmitir conocimiento!
Como siempre un maestro!
Pablo.

Pablo, siempre que hagamos un addChild sobre un objeto de la Clase que hemos definido "SpriteContent", efectivamente ejecutará ese método -si tenemos un objeto de la Clase "Sprite", (o DisplayObject, o MovieClip) seguirá usando el método de toda la vida.- Vamos, lo que creamos es una nueva Clase y los objetos que deriven de esa clase ejecutarán ese método

Código ActionScript :

var mc:MovieClip=new MovieClip()
mc.addChild(algo) //<--método addChild de la Clase MovieClip
var spriteContent=new SpriteContent()
spriteContent.addChild(algo)  //<--método addChild de nuestra clase SpriteContent

De hecho la idea de sobreescribir es opcional, podríamos haber añadido un método addChildAndComprobar(), de modo que nuestros objetos de la Clase spriteContent tendrían dos métodos, el addChild de toda la vida y el que creamos nosotros.

Respecto a si es "algo más lento" como dices, realmente hace dos instrucciones -no se va a notar-. Pero por ejemplo podríamos haber creado una clase que lo que hiciera fuera añadir un ENTER_FRAME. -de hecho, antes de sobreescribir, fue mi idea- Obviamente en ese caso sí que sería más ineficaz (prefiero ineficaz a lento), pero es porque ENTER_FRAME consume "bastantes" recursos

Lo de sobreesctibir metodos me lo dejaste clarisimo Eliseo pero sobre si se ase mas lento o no la aplicacion no me kedo claro, sobre todo la parte de ENTER_FRAME, ineficaz o lento.

Gracias por tu explicación Eliseo me quedó muy claro lo del addChild, pero coincido con marrkitos no me imagino eso de agregar "un EnterFrame"... pero bueno me quedo con lo otro por ahora pq mi cabeza va a estallar (es mucho para un diseñador jeje!)

Saludos!

Pablokorku escribió:

Era sólo un ejemplo, Imaginemos una Clase del tipo

Código ActionScript :

public class SpriteEnterFrame extends Sprite {  
      private var alto:Number;  
      private var ancho:Number;  
      public static const CHANGE_TAMANO:String = "Cambio_tamano";   
      
      public function SpriteEnterFrame (){  
             addEventListener(Event.ENTER_FRAME,comprobarTamano)
      }  
      private function comprobarTamano():void{  
          if (ancho!=width || alto!=height){  
                 dispatchEvent(new Event(CHANGE_TAMANO))  
                 ancho=width  
                 alto=height  
          }  
      } 

Vemos que, cuando cambiemos el tamaño, estamos lanzando un evento CHANGE_TAMANO -igual que hacíamos antes- Pero... ¿qué ocurre? Que siempre que creemos un objeto del tipo "SpriteEnterFrame", estamos creando un ENTER_FRAME (es un modo de hablar). De modo que si tenemos en la película principal algo como

Código ActionScript :

//película principal
for (var i:int=0;i<100;i++){
    var sp:SpriteEnterFrame=new SpriteEnterFrame()
    sp.addEventlistener(CHANGE_TAMANO,hazAlgo)
}

hemos creado 100 ENTER_FRAME. Un ENTER_FRAME es muy lento (bueno, uno no, pero 100 sí que lo es)
Lo "eficaz" hubiera sido tener un solo ENTER_FRAME en la película principal, algo como -no pongo la Clase-

Código ActionScript :

//película principal
addEventListener(ENTER_FRAME,comprobarTamanoDeTodos)
function comprobarTamanoDeTodos(e:Event){
    for (var i:int=0;i<100;i++){
    var sp:SpriteEnterFrame=getChildByName("sp"+i) as SpriteEnterFrame
    if (sp.comprobarTamano()){
                hazAlgo()
    }
}

Pero repito era un EJEMPLO. Y NO, la aplicación NO se hace más lenta o menos por usar clases propias -sino porque esté mal construida la clase-

muy buena explicación me quedó más q claro. Gracias por tu tiempo!
Un saludo!
Pablo.