Axway’s Chief Architect Dale Moberg reflects on the advent of AS2 and the new AS2 Restart. 

Galeria de Fotos carrusel vertical XML y visualizador, como dice el titulo visualizador llamo a que cuando se hace un clic en la foto miniatura, no abre una URL como en todos los casos restantes que tengo subidos, sino que Amplia la foto y luego alli podemos hacer clic para ver la URL.

Es Un Mersh entre 2 galerias de fotos y dejo aqui el FLA en Action Script 2

http://www.controlz.com.ar/di3blog/as2/carrusel_vertical_visualizador.rar

Aqui voy a dejar 2 tipos de carrosul en flash 8 en Action Script 2. Uno es creado por http://www.tutoriales-flash.com y el otro por Flashmo.com

Ambos trabajan con XML y action Script 2.

Para descargar aqui:

flashmo

Tutoriales

tutorial de como hacerlo:

COMO HACERLO.
Las imágenes se van a cargar en la película mediante un archivo XML como el empleado en el Tutorial para hacer una galería de imágenes con carga dinámica en Flash. Es decir, un archivo XML con esta estructura.

Los pasos básicos este tutorial son los siguientes:

Todo el código de la película está en el primer fotograma. Vamos a ir comentándolo de arriba a abajo por bloques. Al final del tutorial podéis verlo todo seguido y descargaros el archivo .fla.

Ajustes para la carga del xml.

System.useCodepage = true;
XML.prototype.ignoreWhite = true;

Para no tener que escribir la ruta completa de las clases que usaremos más adelante.

import flash.display.BitmapData;
import flash.geom.Rectangle;
import flash.geom.Matrix;

Éstos son los parámetros personalizables. Si no queréis comeros la olla con el funcionamiento del ejemplo y simplemente buscáis un carrusel para poner en vuestra web, éstos son los parámetros que necesitáis definir.
- ancho_carrusel. Ancho total en px que ocupará el carrusel.
- ancho_miniatura. Ancho en px de cada miniatura del carrusel en su punto máximo al pasar por el centro del carrusel.
- v_giro. Número mayor de cero que controla la velocidad de giro de manera inversa, es decir, para valores más bajos girará más rápido.
- reflejar. Valor booleano que indica si se proyecta el reflejo del carrusel o no.
- color_fondo. Color de fondo, es necesario para que el desvanecimiento del reflejo quede bien en el caso de que reflejar=true.
- x0. Posición horizontal en el escenario del centro del carrusel.
- y0. Posición vertical en el escenario de la parte inferior del carrusel.
- url_fotos. La url de nuestro archivo XML.
- dir_minis. Directorio donde están los archivos de las miniaturas.

var ancho_carrusel:Number = 700;
var ancho_miniatura:Number = 90;
var v_giro:Number=30;
var reflejar:Boolean = true;
var color_fondo:Number = 0xF4F4F4;
var x0:Number = 365;
var y0:Number = 185;
var url_fotos:String=”asp/verMiniaturas_tutos.asp”;
var dir_minis:String=”miniaturas/”;

Llegado a este punto conviene indicar que para conseguir que el efecto de reflejo quede bien, todas las imágenes han de tener las mismas dimensiones o mantener el mismo ratio alto/alto. Asímismo, los parámetros ancho_carrusel y ancho_miniatura deberán presentar valores adecuados para mostrar correctamente el carrusel según el número de imágenes a rotar.

A continuación, se define una serie de variables que se van a emplear en la película.
- IMG_array. Matriz que almacena la info del XML, esto ocurre dentro de la función cargarMiniaturas() como se verá más adelante.
- incre. Velocidad angular de rotación del carrusel, depende la posición del puntero respecto al propio carrusel.
- num_fotos. Variable que almacena el número de fotos del carrusel.
- num_fotos_cargadas. Variable que indica el número de miniaturas cargadas.
- radio. Radio de giro del carrusel, queda definido por los valores de los parámetros personalizables anteriores.

var IMG_array:Array;
var incre:Number = 0;
var num_fotos:Number;
var num_fotos_cargadas:Number;
var radio:Number = (ancho_carrusel-ancho_miniatura-10)*0.5;

Defino el objeto XML que recibirá los datos, la ruta de la carga y cual es la función que se ejecutará tras la carga.

var miniaturasXML:XML = new XML();
miniaturasXML.onLoad = cargarMiniaturas;
miniaturasXML.load(url_fotos);

La función cargarMiniaturas() es la elegida. Primero asignamos al array IMG_array, antes definido, los nodos del XML que contienen la información de cada archivo de imagen. Así, ya podemos establecer el valor de num_fotos que es la longitud del array. Si, por la razón que sea, no queremos emplear todas las imágenes que retorna el XML podemos definir manualmente el valor de num_fotos. En nuestro caso estamos empleando las propias miniaturas de los tutoriales de este sitio web, y como son unas cuantas, hemos decidido coger sólo las 17 primeras, por eso hemos comentado la línea que hay en negrita en el código para que no se ejecute y hemos establecido un valor de 17 directamente.

Creo estos clips vacíos:
- contenedor_mc. Este clip será el de nivel superior en el carrusel, si se aplica el reflejo, el objeto BitmapData necesario se basará en él.
- carrusel_miniaturas_mc. Este clip creado dentro de contenedor_mc alojará los clips de las miniaturas.

Después algunas operaciones de posicionamiento y ocultamiento en algunos de estos movieclips, inicializamos el contador de imágenes cargadas y nos recorremos el array con la info con un bucle for. Dentro del bucle invocamos la función crearMiniatura() pasando dos parámetros: el nombre del archivo a cargar y un valor numérico incremental que va a definir la posición de cada imagen dentro del círculo del carrusel. Esta función (que definiremos más adelante en el código) se va a encargar de cargar la imagen y darle el tamaño deseado.

function cargarMiniaturas():Void {
IMG_array = this.firstChild.childNodes;
// num_fotos = IMG_array.length;
num_fotos = 17;
var contenedor:MovieClip = _root.createEmptyMovieClip(“contenedor_mc”, _root.getNextHighestDepth());
contenedor._y = y0;
contenedor._visible = false;
var carrusel:MovieClip = contenedor.createEmptyMovieClip(“carrusel_miniaturas_mc”, contenedor.getNextHighestDepth());
carrusel._x = x0;
num_fotos_cargadas = 0;
for (var k:Number = 0; k<num_fotos; k++) {
crearMiniatura(IMG_array[k].attributes.nombre,k);
}
}

La función crearMiniatura(), como ya hemos dicho anteriormente, se encarga de cargar cada una de las miniaturas y reescalarlas. Creamos un clip vacío llamado foto_0, foto_1,…. y dentro de éste otro llamado foto que es donde cargaremos la imagen con un objeto de la clase MovieClipLoader. En el tutorial Carga de clips externos en Flash. La clase MovieClipLoader se explica el uso de esta clase.

Cada vez que se completa la carga de una imagen y ya está disponible se le asignan las acciones a ejecutar al hacer clic sobe ella. En nuestro caso, abre la página del tutorial correspondiente, menos en el caso de que la miniatura sea la del logo con la efe, que abre la página de principal de nuestro sitio web.

Se comprueba si están cargadas todas, en caso afirmativo, se ejecuta la función girar_carrusel() con un retardo de medio segundo. A cada miniatura se le asigna como propiedad orden el parámetro que recibe de la función.

function crearMiniatura(ruta:String, orden:Number):Void {
var clip:MovieClip = contenedor_mc.carrusel_miniaturas_mc.createEmptyMovieClip(“foto_”+orden, contenedor_mc.carrusel_miniaturas_mc.getNextHighestDepth());
var dentro:MovieClip = clip.createEmptyMovieClip(“foto”, clip.getNextHighestDepth());
clip.orden = orden;
var mi_mcl:MovieClipLoader = new MovieClipLoader();
var miListener:Object = new Object();
mi_mcl.addListener(miListener);
mi_mcl.loadClip(dir_minis+ruta, dentro);
miListener.onLoadStart = function(target_mc:MovieClip) {
target_mc._alpha = 0;
};
miListener.onLoadProgress = function(target_mc:MovieClip, bytesLoaded:Number, bytesTotal:Number) {
// aquí podéis poner acciones para mostrar una precarga
};
miListener.onLoadInit = function(target_mc:MovieClip) {
var coef:Number = target_mc._width/ancho_miniatura;
target_mc._height = int(target_mc._height/coef);
target_mc._width = ancho_miniatura;
target_mc._alpha = 100;
target_mc._x = -(int(target_mc._width*0.5));
target_mc._y = 0;
// función que ejecuta al pulsar cada miniatura
target_mc.onRelease=function(){
if (ruta.indexOf(“.gif”) != -1) {
var temp_array:Array = ruta.split(“.gif”);
getURL(“http://www.tutoriales-flash.com/tutorial.php?id_tuto=”+temp_array[0],”_blank”);
} else {
getURL(“http://www.tutoriales-flash.com”_blank”);
}
num_fotos_cargadas++;
if (num_fotos_cargadas>=num_fotos) {
setTimeout(_root.girar_carrusel, 500);
}
};
}

La función girar_carrusel() se invoca cuando se hayan cargado todas las miniaturas y se encarga como su propio nombre indica de girar el carrusel. Hemos dividido el código en dos bloques para facilitar la comprensión de éste.

La programación del bloque 1 se va a ejecutar sólo una vez en la película, en el momento de ejecutar la función, y básicamente comprende las rutinas necesarias para crear el efecto de espejo. Primero se crea el clip vacío reflejo_miniaturas_mc que es donde se duplicará el carrusel reflejado verticalmente. Después crearemos el clip vacío sombreado_mc por encima del anterior en que dibujaremos con la API de dibujo de Flash un rectángulo con un relleno degradado usando únicamente el valor de la variable color_fondo y distintos niveles de transparencia (alpha) del 0 a 100. Como se ve, hemos empleado el método createGradientBox de la clase Matrix, este método es especial para la generación de rellenos degradados, ya os prepararemos un tutorial o un truco explicando su aplicación, mientras tanto consultad la documentación de Flash u otras fuentes. Para finalizar este primer bloque, reposicionamos adecuadamente estos clips creados.

El contenido del bloque 2 se va a ejecutar en cada fotograma de giro del carrusel. En primer lugar, se calcula un nuevo valor de la velocidad angular incre en función de la posición horizontal del puntero respecto al centro horizontal del carrusel x0 y el valor de la variable v_giro definida al principio del código. Con este nuevo valor de incre establecido, ejecutamos el método girar() de cada una de las miniaturas por medio de un bucle for. Este método que escalará y posicionará cada miniatura se definirá más tarde.

A continuación de recorrernos el bucle, comprobamos de nuevo el valor de la variable reflejar, si es verdadero (true) actualizo el contenido del clip reflejo_miniaturas_mc con la imagen duplicada y reflejada del carrusel del fotograma actual. Esto lo hacemos con la ayuda de una instancia de la clase BitmapData. Primero copiamos el contenido en el objeto bmp y después lo adjuntamos (attachemanos suena mejor?) a reflejo_miniaturas_mc que como tiene la propiedad _yscale=-100 se ve reflejado respecto al original.

function girar_carrusel() {
// inicio bloque 1 ————————————————
contenedor_mc._y = y0-contenedor_mc._height;
if (reflejar) {
var reflejo:MovieClip = _root.createEmptyMovieClip(“reflejo_miniaturas_mc”, _root.getNextHighestDepth());
reflejo._yscale = -100;
reflejo._y = contenedor_mc._y+contenedor_mc._height*2+1;
var myMatrix:Matrix = new Matrix();
myMatrix.createGradientBox(ancho_carrusel,contenedor_mc._height,Math.PI/2,0,-15);
var sombreado:MovieClip = _root.createEmptyMovieClip(“sombreado_mc”, _root.getNextHighestDepth());
var colors:Array = [color_fondo, color_fondo, color_fondo];
var alphas:Array = [40, 90, 100];
var ratios:Array = [0, 160, 255];
sombreado.beginGradientFill(“linear”,colors,alphas,ratios,myMatrix);
sombreado.moveTo(0,0);
sombreado.lineTo(ancho_carrusel,0);
sombreado.lineTo(ancho_carrusel,contenedor_mc._height);
sombreado.lineTo(0,contenedor_mc._height);
sombreado.lineTo(0,0);
sombreado._y = y0+1;
sombreado._x = x0-sombreado._width*0.5;
}
// fin bloque 1 ————————————————
// inicio bloque 2 ————————————————
delete contenedor_mc.onEnterFrame;
contenedor_mc.onEnterFrame = function() {
incre += (_root._xmouse-x0)/_root.v_giro;
for (var k:Number = 0; k<=num_fotos; k++) {
this.carrusel_miniaturas_mc["foto_"+k].girar();
}
if (reflejar){
var bmp:BitmapData = new BitmapData(ancho_carrusel+100, this._height, true, 0×00000000);
var myRectangle:Rectangle = new Rectangle(0, 0, ancho_carrusel+100, this._height);
bmp.draw(this, new Matrix(), new ColorTransform(), “normal”, myRectangle,true);
_root.reflejo_miniaturas_mc.attachBitmap(bmp, 1, “auto”, true);
}
};
contenedor_mc._visible = true;
// fin bloque 2 ————————————————
}

El método girar() se va definir empleando la propiedad prototype. Esto quiere decir que este método va a estar disponible para todas las instancias de una clase, en nuestro caso, la clase MovieClip. En función de la velocidad incre, del valor de la propiedad orden de la miniatura y del número de fotos totales, num_fotos, cada miniatura se posicionará en un angulo definido en la variable degrees dentro del círculo del carrusel.

MovieClip.prototype.girar = function() {
var degrees:Number = _root.incre+(360*this.orden/num_fotos);
var radians:Number = degrees*Math.PI/180;
if (Math.sin(radians)<0) {
this._alpha = 15;
} else {
this._alpha = 100;
}
this._x = radio*Math.cos(radians);
this._xscale = (1-Math.cos(radians+Math.PI*0.5))*99-99;
this.swapDepths(int(this._xscale*10));
};

Ahora que ya tenéis el carrusel funcionando es el momento de que adaptéis el código a vuestro gusto. Aquí tenéis el archivo .fla del ejemplo, el resto, el xml de las imágenes y las imágenes en sí poned las vuestros. carrusel.fla

Encontre este link que dejo a disposicion, me parecio muy bueno como muestra la creacion de funciones y seguro que me ahorrara mucho tiempo cuando necesite algo similar.

Creacion de una Galeria de fotos flash con XML en Action Script 2http://www.tutoriales-flash.com/tutorial.php?id_tuto=29

Detalle:

Galeria de foto flash 8, AS2, XML, miniatura o thumbnails y foto grande.

Link de descarga

Aqui esta el Tutorial, pero por supuesto la fuente es la puesta arriba…

COMO HACERLO.
Como veremos más delante, este tutorial es el resultado de juntar varios tutoriales existentes en tutoriales-flash.com.

Lo primero que hay que hacer es crear las miniaturas en nuestro programa de manipulación de imágenes preferido. Tanto las miniaturas como los originales deben estar en formato JPEG no progresivo, PNG o GIF, de lo contrario, Flash Player no podrá cargarlas.

Una vez que tengamos listos todos los JPEG, los metemos en dos directorios llamados originales y minis. Es importante que cada imagen tenga el mismo nombre de archivo en el original y en la miniatura.

Después de esto, preparamos el archivo XML que nos va a dar la lista de fotos.
En este ejemplo se trata del archivo http://www.tutoriales-flash.com/php/verMiniaturas.xml que podéis visualizar. Para aprender como enviarle a Flash un XML con la lista de archivos de determinado directorio tenéis disponible estos otros tutoriales.

Recepción de datos externos en Flash. La clase XML.

Como leer los archivos que hay en una carpeta del servidor con ASP y pasarlo a Flash.

Como leer los archivos que hay en una carpeta del servidor con PHP.

Para el resto del tutorial no saldremos de Flash. Todo el código del ejemplo va en el primer fotograma salvo unas pequeñas acciones en los botones de pasar página. Vamos a ir poniendo el código de este primer fotograma en bloques para comentarlos.

// acciones en fotograma 1
stop();
System.useCodepage = true;
XML.prototype.ignoreWhite = true;
import mx.transitions.Tween;
// separacion-> distancia entre las imágenes
// tanto horizontal como vertical
var separacion:Number = 116;
// vbles para pasar de página
var pagina_actual:Number = 1;
var num_paginas:Number;
// array donde metemos los elementos del XML
var IMG_array:Array;
// objeto XML que carga la lista de miniaturas

Hasta aquí hemos definido una serie de ajustes iniciales.

var miniaturasXML:XML = new XML();
miniaturasXML.onLoad = mostrarMiniaturas;
miniaturasXML.load(“/asp/verMiniaturas.asp”);
// funcion que se ejecuta al cargar el XML
function mostrarMiniaturas():Void {
// contadores de columna y fila para
// disponer las miniaturas
var fila:Number = 0;
var col:Number = 0;
// paso los datos del XML al array
IMG_array = this.firstChild.childNodes;
// como caben 12 fotos por página podemos
// saber el núm de páginas necesarias para
// mostrar todas las fotos
num_paginas = Math.ceil(IMG_array.length/12);
// creo el clip donde meteremos todas las miniaturas
var lienzo:MovieClip = _root.createEmptyMovieClip(“lienzo_miniaturas”, _root.getNextHighestDepth());
// lo posiciono donde nos conviene
lienzo._x = 19;
lienzo._y = 100;
// y lo enmascaro con el clip situado en la
// capa mascara. se enmascara para hacer el deslizamiento del
// clip cuando tengamos muchas miniaturas y no entren todas a
// la vez en pantalla (nuestro caso)
lienzo.setMask(mascara_mc);
// recorro el array que contiene la lista con los nombres de
// los archivos de las miniaturas e invoco la función crearMiniatura
// que es la que carga la imagen, la recoloca, le pone un pequeño
// marco y le asigna las acciones para verla ampliada
for (var k:Number = 0; IMG_array[k]; k++) {
// extraigo la ruta del archivo de imagen
//var ruta:String = “minis/”+IMG_array[k].attributes.nombre;
// como sólo tengo tres columnas, cuando llegue a
// la tercera, avanzo una fila y retorno a la primera
if (col>2) {
col = 0;
fila++;
}
// creo la miniatura. extraigo la ruta del archivo de imagen
// y la paso como tercer parámetro
crearMiniatura(col, fila, IMG_array[k].attributes.nombre);
col++;
}
}

En el bloque anterior hemos definido el objeto XML que va a recibir los datos y también la función encargada de procesarlos.

function crearMiniatura(columnaF:Number, filaF:Number, ruta:String) {
// bajo_clip es el clip que contendrá el marco de la miniatura
var bajo_clip:MovieClip = lienzo_miniaturas.createEmptyMovieClip(“bajo_”+filaF+”_”+columnaF, lienzo_miniaturas.getNextHighestDepth());
// clip contendrá la imagen
var clip:MovieClip = lienzo_miniaturas.createEmptyMovieClip(“foto_”+filaF+”_”+columnaF, lienzo_miniaturas.getNextHighestDepth());
// para cargar la miniatura definimos un objeto MovieClipLoader
// y un objeto detector de eventos
var mi_mcl:MovieClipLoader = new MovieClipLoader();
var miListener:Object = new Object();
mi_mcl.addListener(miListener);
clip.valor = “aaa”;
// cargamos la imagen
mi_mcl.loadClip(“/minis/”+ruta, clip);
miListener.onLoadStart = function(target_mc:MovieClip) {
// cuando comienza la carga de la imagen
// ponemos al _alpha a 0
target_mc._alpha = 0;
};
miListener.onLoadProgress = function(target_mc:MovieClip, bytesLoaded:Number, bytesTotal:Number) {
// aquí podéis poner acciones para mostrar una precarga,
// este caso no lo hemos considerado oportuno
};
// cuando ya se ha completado la carga y tenemos disponible el clip
miListener.onLoadInit = function(target_mc:MovieClip) {
// recolocamos la imagen (todavía está oculta, con _alpha=0)
target_mc._x = (separacion*columnaF)+(100-target_mc._width)*0.5;
target_mc._y = (separacion*filaF)+(100-target_mc._height)*0.5;
// recolocamos el marco que rodea a la foto
bajo_clip._x = target_mc._x-5;
bajo_clip._y = target_mc._y-5;
// dibujamos el marco
with (bajo_clip) {
beginFill(0xffffff);
lineStyle(1, 0xEEEEEE, 100);
lineTo(target_mc._width+10, 0);
lineTo(target_mc._width+10, target_mc._height+10);
lineTo(0, target_mc._height+10);
lineTo(0, 0);
endFill();
}
// al pinchar sobre el área del marco,
// mostramos la foto grande con la función
// verFotoGrande
bajo_clip.onRelease = function() {
verFotoGrande(ruta);
};
// muestro la miniatura animando el _alpha hasta 100
var myTween:Tween = new Tween(target_mc, “_alpha”, mx.transitions.easing.Regular.easeOut, 0, 100, 2, true);
};
}

Hasta aquí hemos definido la función que crea cada una de las miniaturas. En este tutorial tenéis material de apoyo.

Carga de clips externos en Flash. La clase MovieClipLoader.

function verFotoGrande(ruta:String) {
clearInterval(intervaloColor);
// creo el clip donde irá la foto grande en una profundidad fija
// para que se reemplace cada vez que pincho en una miniatura
var grande:MovieClip = _root.createEmptyMovieClip(“grande_mc”, 2*IMG_array.length+11);
// igual con el clip que contendrá el marco
var bajo_grande:MovieClip = _root.createEmptyMovieClip(“bajo_grande_mc”, 2*IMG_array.length+10);
// posición vertical fija
grande._y = 100;
// para cargar la foto grnade definimos otro objeto MovieClipLoader
// y otro objeto detector de eventos
var grande_mcl:MovieClipLoader = new MovieClipLoader();
var grandeListener:Object = new Object();
grande_mcl.addListener(grandeListener);
// cargo la foto grande
grande_mcl.loadClip(“/originales/”+ruta, grande);
grandeListener.onLoadStart = function(target_mc:MovieClip) {
// aplico una transformación de color que deja el clip
// tintado de blanco
myColor = new Color(target_mc);
myColorTransform = new Object();
myColorTransform = {ra:100, rb:255, ga:100, gb:255, ba:100, bb:255, aa:100, ab:0};
myColor.setTransform(myColorTransform);

};
grandeListener.onLoadProgress = function(target_mc:MovieClip, bytesLoaded:Number, bytesTotal:Number) {
// aquí podéis poner acciones para mostrar una precarga,
// este caso no lo hemos considerado oportuno
};
grandeListener.onLoadInit = function(target_mc:MovieClip) {
// recolocamos la imagen (todavía está oculta)
target_mc._x = 382+Math.round((315-target_mc._width)*0.5);
// recolocamos el marco que rodea a la foto grande
bajo_grande._x = target_mc._x-5;
bajo_grande._y = target_mc._y-5;
// dibujamos el marco
with (bajo_grande) {
beginFill(0xffffff);
lineStyle(1, 0xEEEEEE, 100);
lineTo(target_mc._width+10, 0);
lineTo(target_mc._width+10, target_mc._height+10);
lineTo(0, target_mc._height+10);
lineTo(0, 0);
endFill();
}
// con estas rutinas hacemos la transición de color desde el blanco
var indiceColor:Number = 255;
intervaloColor = setInterval(cambiarColor, 10);
function cambiarColor() {
myColorTransform = {ra:100, rb:indiceColor, ga:100, gb:indiceColor, ba:100, bb:indiceColor, aa:100, ab:0};
myColor.setTransform(myColorTransform);
indiceColor -= 2;
if (indiceColor == -1) {
clearInterval(intervaloColor);
}
}
};
}

Ya hemos creado la foto grande. Para hacer las transición de la foto grande hemos usado el método setTransform de la clase Color. Es este otro tutorial se explica un ejemplo de su uso.

Tutorial para cambiar el color de un clip en Flash, usando ActionScript.

// con esta función desplazo el lienzo de las miniaturas para
// pasar de página
function moverLienzo(posY:Number):Void {
var myTween:Tween = new Tween(lienzo_miniaturas, “_y”, mx.transitions.easing.Regular.easeOut, lienzo_miniaturas._y, posY, 1, true);
}
// deshabilito de inicio el botón de volver atrás
// ya que se muestra la página 1
pMenos_btn.enabled = false;
pMenos_btn._alpha = 30;

Por último queda el código de los botones de pasar página.
En página-

on (release) {
// activo el botón página+
pMas_btn.enabled = true;
pMas_btn._alpha = 100;
moverLienzo(100-(pagina_actual-2)*464);
pagina_actual–;
// si llego a la primera página
// ya no puedo retroceder, por tanto
// deshabilito el botón
if (pagina_actual == 1) {
pMenos_btn.enabled = false;
pMenos_btn._alpha = 30;
}
}

En página+

on (release) {
// activo el botón página-
pMenos_btn.enabled = true;
pMenos_btn._alpha = 100;
moverLienzo(100-(pagina_actual*464));
pagina_actual++;
// si llego a la última página
// ya no puedo avanzar, por tanto
// deshabilito el botón
if (pagina_actual == num_paginas) {
pMas_btn.enabled = false;
pMas_btn._alpha = 30;
}
}

En este tutorial os hemos enseñado los pasos para hacer una galería de fotos, ahora es el momento de experimentar con código e introducir vuestras propias variaciones sobre el ejemplo.

Podéis descargaros este mismo ejemplo y ver cómo funciona: galeria.zip

Peter Corliss is a Product Manager at Inovis and is responsible for the product strategy and planning, identifying market requirements and defining specific features for our BizManager line of products. He is also a key member of the agile development team for BizManager. Peter recently took out some time to explain the new specification, AS2 Restart.

Q: What is AS2 Restart?

AS2 Restart enables companies to leverage the security and features of the AS2 protocol, while transferring very large files over networks which can be subject to connection timeouts and other failures.

Q: Why is it needed?

AS2 Restart is needed due to the increasing size of data being exchanged over networks.  These critical files – often in excess of hundreds of megabytes or even gigabytes – can be subjected to inconsistencies within connections, and the time impact of potentially having to resend from start isn’t acceptable.

Q: How was the idea for AS2 Restart conceived and what was the process for creating it?

During the initial round of interoperability testing for Chunked Transfer support as an optional AS2 profile, it was identified that simply chunking data would not be sufficient to overcome the issues with very large file transfers.  Inovis played a key role in defining the resulting AS2 Restart feature through submitting initial drafts and helping to refine the final protocol update proposal.

Q: Which companies can benefit from AS2 Restart the most?

As more industries adopt Managed File Transfer applications as part of their integral  business practice, the resulting expansion of typical data content into larger and less compressible formats; image-laden catalog data, marketing .pdf presentations, large medical images, and audio/video files are among the types of content that can now more reliably leverage the benefits of AS2.

Q: How will AS2 Restart affect business going forward?

AS2 is already a defacto standard for B2B data transfers.  EDI and XML data can now be alongside less traditional data formats which are becoming critical aspects of business communications as network bandwidth, and the size of data crossing over it, continues to increase.

To learn more about AS2 Restart, you may read the press release here.

Recently I ran into an issue with the Http ContentType used when sending messages using the As2EdiSend pipeline.

Using the standard out-of-the-box pipeline, the web content type will be set to “application/EDI-EDIFACT“, regardless of the value supplied in the Party as AS2 Receiver configuration.  If your trading partner is using BizTalk as well, this is not an issue, as BizTalk, and probably some other AS2 servers, do not consider the content type before routing the AS2 payload for further parsing by an EDI interpreter.

However, our trading partner uses a specific AS2 server, Axway, that will only route to the EDI sub-system if the content type is, quite correctly, “application/EDIFACT” (note the small difference).  This is the correct value, according to the RFC (link – see Section 4.2).

Our workaround was to add a custom pipeline component in between the EDI Assembler stage and the AS2 Encoder stage in a custom Pipeline.  This custom component only does one thing, clears the IBaseMessage.BodyPart.ContentType property of the current message stream:

IBaseMessagePart bodyPart = pInMsg.BodyPart;
if ((bodyPart != null))
{
// Override the default content type with the one we want to use
pInMsg.BodyPart.ContentType = "";
}
return pInMsg;

By default, the EDI Assemble stage allocates a default value of “application/EDI-EDIFACT”.  The AS2 Encoder will lookup the appropriate content type to use from the Party configuration, but only if the content type has not been supplied.  As the EDI stage has already allocated a value, this “optional” value is rendered useless.  By “clearing” the default value, we allow the AS2 stage to use the appropriate value

Bom hoje vou explicar como se faz campos de texto por AS 2.0 e 3.0

Para começar vocês não vão precisar de nada, basta abrir o flash clicar no frame e copiar e colocar o código para ver funcionar.

Em AS 2.0 temos a função createTextField
Então vamos ver como ela funciona:

/*
* Criando um campo de texto dinamico
*/
var campo:TextField = this.createTextField(‘campo’, 1);
/*
* Como usar
*/
campo.text = “um texto de testes”;

Bom como podem ver é muito fácil criar campos de texto em AS o this significa que ele vai criar onde você já está, se eu colocar _root ele vai criar no palco principal… mesmo se existir uma função chamando dentro de um MovieClip, se estiver escrito _root é no palco e se estiver this. é onde ele se encontra
A declaração var campo:TextField serve apenas para indicar para o flash que aquela variavel tem as propriedades de texto então se você só digitar depois de declarar a variavel campo.(ponto) ele vai mostrar ja todas as propriedades do campo de texto que você pode usar.

Agora como fazer isso em AS 3.0

/*
* Criamos o campo de texto
*/
/*
* IMPORTANTE NUNCA ESQUECER
*/
import flash.text.TextField;
// Aqui eu crio o nosso campo de texto
var campo:TextField = new TextField();
// coloco um texto qualquer
campo.text = ‘um texto de testes’;
// adiciono ao palco
addChild(campo);

Como pode-se ver em AS 3.0 eh diferente de AS 2, você declara depois onde vai adicionar o campo, como eu só escrevi addChild(campo) é a mesma coisa que eu estiver colocando o campo no root do palco, se eu colocar MovieClip.addChild(campo) eu vou estar adicionando dentro de um MovieClip
E lembre-se que em AS 3.0 é necessário importar todas as coisas que você estiver trabalhando… campos de texto etc.

E por hoje é só, espero ter ajudado as pessoas nessa passagem de AS 2.0 para 3.0

abs

We are having so much fun with this curriculum, and I find myself adding more and more to it because the kids are so interested. We are learning about the West, and we added some books on California because I thought this would be a good time to get in some state history. We had to backtrack a little time-wise, but the kids did not seem to mine. We reviewed the early history of California (the native peoples and the missions), and we read about the Gold Rush. Books I added are:

Gold Fever!: Tales from the California Gold Rush

Twelve Travelers, Twenty Horses

Dragon’s Gate: Golden Mountain Chronicles: 1867

I am a film nut, so I am taking advantage of this great time period by having the kids watch as many Westerns as they want. The kids love hearing about the O.K. Corral, so of course we watched My Darling Clementine. We also watched Red River and parts of one of my favorite films, The Searchers. I could write pages on why that film is one of the greatest of all times, but I’ll save that for my film blog. Needless to say it is a beautiful film that I think everyone should see. However the topics are a little mature, so the kids and I just watched a few scenes together.  I am hoping to add in a few other films this week before we finish our study of the west. We have to finish the documentary The West, and we are going to read Annie Oakley (DK Biography) this week too.

The ending of My Darling Clementine – the Gunfight at the O.K. Corral:

Another week of learning about The West. We are really enjoying this time period, and I think part of the reason is that we live in California. The kids seem more interested in history when it happened where they live. This week we learned about The Wild West. Part of learning about the Wild West is learning about outlaws, which the kids find fascinating. They had so much fun learning about outlaws that I decided to have them dress up as an outlaw and have them pose for wanted pictures. Here are the results:

Would you like to make your own wanted posters? There are numerous templates available on the internet. I used this one, and the poster was so easy to make. A fun project to add to your study of The West.

Hoje vou dar um pequeno exemplo de como usar o tween do flash
Fazendo uma bolinha ir e voltar de uma posição de uma maneira simples

Eis o código:

//Importo as classes necessárias
import mx.transitions.*;
import mx.transitions.easing;

//Crio meu tween que vai fazer a animação
var primeiroTween:Tween = new Tween();
//Crio minha variavel verificadora
var foi:Boolean = true;

//Agora dou a bolinha intanciada de bola no palco a ação de clic
bola.onPress = function() {
//Se foi estiver em true, ele executa a primeira ação
if(foi) {
//Aqui faço a bolinha se movimentar no eixo x de 0 a 200 em 1 segundo
primeiroTween = new Tween(bola, “_x”, Back.easeOut, 0, 200, 1, true);
//Aqui ao terminar a ação do movimento da bolinha eu troco o valor da minha variavel
//assim evito que multiplos clics façam com que ela vá para proxima ação
primeiroTween.onMotionFinished = function() {
foi = false;
}
//Aqui é se ela já foi então volta
}else {
//Para ela voltar eu uso o yoyo() que faz a ação inicial ao contrário
primeiroTween.yoyo();
}
}

Simples fácil e pratico

Agora só aplicar para outras opções
Té mais

Go to http://sublimesite.com/projects.php to see the counter in action, and get it from there

If you like it why not bookmark it or make it your homepage and watch the days countdown.

(picture not the actual thing)

I made this because I felt that the ones I found on the net were just to simple.

To embed it
<object><param name=”movie” value=”http://newcountdown.netai.net//callOfDuty.swf”><embed src=”http://newcountdown.netai.net//callOfDuty.swf” width=”1024″ height=”431″></object>

Embed on forums
[flash=1024,431]http://newcountdown.netai.net//callOfDuty.swf”[/flash]

change the size to meet your needs!!!

Features:

• Counts days, hours, minutes, seconds, and milliseconds until the game is released
• Rolling smoke for a more advance look
• Heart monitor… because well… it just looks cool
• Quick, it doesn’t lag or hiccup like the other ones I’ve found
• It’s not just for form sigs
• And last it looks GOOD!!!

If you for whatever reason can not use the flash countdown here is a php one. It’s not as good and you have to refresh the page for it to count but it works and still looks good.

(refresh page to see it work)

Instructions:
place this url into image tags : http://newcountdown.netai.net//countDown.php
like so
[img]http://newcountdown.netai.net//countDown.php[/img]
OR
<img src=”http://newcountdown.netai.net//countDown.php”>

Have anything that should be added or changed leave a comment.

Empresa: Perdigão
Website: www.perdigao.com.br/kitsNatalinos

Projeto

Design em Flash e AS2 e animações sobre o produtos com sistema de orçamento online.

Empresa: Carina Duek
Website: www.carinaduek.com.br

Projeto

Design em Flash e AS2.
Coordenação e programação em Flash AS2

mini site Seat Exeo

Insertion du modèle Exeo ST au mini site existant. Intégration graphique et vidéo. Ajout d’une pop up et refonte du menu. Développé en AS3.

Un dentiste à Paris

Site français/anglais réalisé en Flex – Bande son Caravane Palace.

Danielsandpartners

Site français/anglais réalisé en Flash, développé en AS2.

site Frieh & Associés - Avocats à Paris

Réalisation en Flash d’un site multilangues anglais/français. Développé en AS2.

mini site Flash Issey Miyake

mini site Conforama

Réalisation en Flash d’un mini site avec bundle, mosaïque et pop up. Développement en AS2 avec impératif de fonctionnement avec un Flash Player 8.0.22

Today Tru set up a recreation of a Civil War Battle, The Battle of Fredericksburg. It was another project from our American Story 2 curriculum.  He spent a good deal of time doing it, and even got Decca involved. Decca placed the cannons for him, and Tru did everything else. After they showed me their battle scene, they acted out the huge battle. It was over within a minute, but it was fun.

Of course they used their toys. It looks more like a civil war on another planet.

The North

vs.

The South

The ASDoc Tool

Further to my post on Java Style Docs with ZenDoc, I’ve found and used a better tool ASDoc.

I’ve used parts of FDTKit to enable an ANT script to create a directory with the documentation.

The process of using FDTKit can be viewed here: FDTKit Documentation & Usage Guide, theres too much information here for just running the “doc-asdoc” from the build.xml.

The build.xml should be present at the ‘top level’ of the checked out project

Comments in the ActionScript Code should follow wherever possible the Java standard : Javadoc comments should have the following form

Not all the Javadoc tags are supported though, for a list of supported tags see: ASDoc tags

For using the @see tag see:
Using the @see tag

Another error that has turned a good number of people’s hair to gray is the 202 (Accepted but still processing error).

Problem Description: The message that you receive will be an As2 Message and then every thing will be fine and the message will go in to active state and then the problem starts, it refuses to come out from the active state and even when you turn on the “suspend on failed request” still the same thing happens. Eventually only one thing that will guide you is the 202 error in the event log.

Solution: The error will occur when you use a Request-Response to receive an AS2 Message and then want to send a As2 A-sync MDN. This error occurs as the processing is over, but a response should be sent through the connection to close the connection. In such situation use the normal receive port and every thing should start working. If still not working please update the thread.

Vou aqui ensinar como que se recupera os dados do seu Twitter
Para começar vocês precisam saber que seu conteudo do twitter não pode ter um cadeado… ou seja tem que ser um conteúdo aberto a todos… se for um conteúdo fechado o código não irá funcionar.

Então tudo que vocês vão precisar fazer é pegar um componente de scroller nos componentes do flash, ctrl + F7 abre os componentes lá você escolhe a opção UIScrollBar arraste para o palco depois delete… pois você só precisa dele na biblioteca.

Feito isso vamos ao código:

/*
* Carregando o Twitter em seu flash
* Criado por Thiago de Oliveira Cruz
*/

//Primeiro passo é criar meu xml
var TwitterXML:XML = new XML();

//Crio meu campo de texto
var campo:TextField = this.createTextField(“campo”, 1, 20, 20, Stage.width – 50, Stage.height);
//Do a propriedade de multiline para ele e wordWrap
campo.multiline = true;
campo.wordWrap = true;

/*
* Crio meu scroll com o UIScrollBar
* (precisa colocar esse componente na biblioteca senão, não funciona)
*/
this.createClassObject(mx.controls.UIScrollBar, “scroller”, -5);
//Coloco o tamanho do campo igual ao palco
scroller.setSize(16, Stage.height);
//Digo qual a posição do X do scroll
scroller._x = Stage.width – 16;
//Coloco o scrill ao campo
scroller.setScrollTarget(campo);

//Carrego o meu xml do twitter
TwitterXML.load(‘http://twitter.com/statuses/user_timeline/ThiagoOCruz.xml’);
//Ignoro os espaços em branco
TwitterXML.ignoreWhite = true;
TwitterXML.onLoad = function() {
//Crio um loop para pegar o conteudo do meu twitter
for(var i:Number = 0; i < TwitterXML.firstChild.childNodes.length; i++){
//Recupero aqui apenas o campo text
campo.text += this.childNodes[0].childNodes[i].childNodes[2].firstChild.nodeValue + newline + newline;
}
}

E é só
Agora é só se divertir com os nodes do XML e buscar as informações que você quer.

Abraços e até a proxima

The error is a notorious creature that can sip hours of work from your daily life. It did for me, then I started collecting steps to go around this hurdle when I started my As2 journey.

To Start with, our friends in BizTalk Hot Rod have produced a good List we will add on that list for more convenience

You can verify the following in order to troubleshoot the 500 Internal Server

1. Verify the physical path drive:\Program Files\Microsoft BizTalk Server 2009\HttpReceive (If its a BizTalk 2009 installation for R2 it will \Program Files\Microsoft BizTalk Server 2006\HttpReceive)
2. On the Virtual Directory Access Permissions page, select Execute (such as ISAPI applications or CGI).
3. Verify the account which application pool is running is part of IIS worker process group (IIS_WPG).
4. Check whether at least one ReceiveLocation is listening to this HTTP URL (And only one Receive location can listen to a website)
5. Make sure the identity used in the application pool for the BtsHttpReceive virtual directory has access to the BiztalkMsgBoxDb.
6. Make sure that an Isolated host instance is created for HTTP Receive adapter.
7. Make sure that the receive handler is running under 32 bit host instance. This is required for AS2 functionality to work.
8. Make sure that IIS6 is configured to allow your BTSHTTPReceive.dll ISAPI extension to run. By default, it will block any attempt to do so until you go to the IIS manager console, into the Web Services folder and manually enable it.

But there are other culprits behind all of this which are hard to catch,

The Isolated Host and the IIS Host should run on the same account and should that has SQL access permission. In the act of solving the 500 Internal Server error the main rules should not be broken and this is one of them.

And another major pain is the worker process, w3wp process that will be running, so as mentioned above you will check the app Pool and change the account. But the worker process which has been spawn before will be running with the old account you will notice it Task manager under the user account column value of the process. So after any change that you do to the app pool kill the process and do a recycle of the app pool. After that check if the worker process is running with the account.

The most helpful tool for Debugging is the Event log. Never over look it, there will be warning as well as errors, please go through them and you will know the exact reason for the failure 9 out of 10 times. Checking the event log and following its guidance makes you a better 500 Internal Server Error debugger (or in general a better debugger).

If you have any other way to Tackle 500 Internal Server error in BizTalk when encountering As2, please comment about it . There is always a new or a better method and it will be more helpful if its shared.

AS2 and AS3 – Most other engines are only developed for AS2 or AS3 but not both. — http://blog.greensock.com/tweenlite/

This is an overview of how to use filters via the popular animation engine TweenLite. For the purposes of this tutorial I’m simply using the “delay” property to time the overall animation flow. Check out the relevant forum for info on how to manage animation sequences using TimeLineLite. Here’s a Zip with the .fla.

The AS3 code:

import com.greensock.*;
import com.greensock.easing.*;
import com.greensock.plugins.*;

TweenPlugin.activate([BlurFilterPlugin]);

/*
 * assumes you have graphic assets named couple1, couple2 on the stage
 * for pure AS3 apps, use the embed Flex meta tag to embed the asset
 * and wrap this code in a class file
 */

var _tweenSpeed1:Number = 0.55;
var _tweenSpeed2:Number = 1;
var _tweenSpeed3:Number = 0.33;
var _blurYamount1:uint = 60;
var _noBlur:uint = 0;

//init blur filter & position on hidden assets, using TweenLite
TweenLite.to(couple1, 0.33, {delay:0, y:200, blurFilter:{blurY:_blurYamount1}});
TweenLite.to(couple2, 0.33, {delay:0, y:200, blurFilter:{blurY:_blurYamount1}});

//remove blur as the hidden asset animates onto the stage
TweenLite.to(couple1, _tweenSpeed3, {delay:1, blurFilter:{blurY:_noBlur}, y:0, ease:Sine.easeOut, overwrite:false});

//move the asset off stage, as per storyboard, blur it again, as you move it
TweenLite.to(couple1, _tweenSpeed2, {delay:3, blurFilter:{blurY:_blurYamount1}, y:200, ease:Elastic.easeOut, overwrite:false});

//remove blur as the hidden asset animates onto the stage
TweenLite.to(couple2, _tweenSpeed1, {delay:3.5, blurFilter:{blurY:_noBlur}, y:10, overwrite:false});

//move the asset off stage, as per storyboard, blur it again, as you move it
TweenLite.to(couple2, _tweenSpeed2, {delay:6, blurFilter:{blurY:_blurYamount1}, y:200, ease:Elastic.easeOut, overwrite:false});

For Flash banners, for example, it’s often easier to use AS2, because a) Designers don’t know AS3, b) you’ll get that extra 1% or so of users who don’t have Flash Player 9 or 10 yet and c) some versions of Flash 9 player had an AS3 preload bug on IE on Windows that didn’t allow a file to preload itself properly. Why not just do the AS3 workaround with an empty wrapper SWF that preloads the main SWF? Depending on the situation, sometimes, for smaller files like banners, it’s easier to send the client 1 SWF with everything in it, than saying, “hey, do you have an external assets server that I can upload the extra SWFs to so the banner can load it in at run-time?” I’ve had cases where a client uses an Ad Server that they either don’t quite know how to fully use or that’s weirdly set to only accept 1 SWF. I’ve read about server load-balancing issues forcing Flash guys to dump everything into 1 SWF as well. Basically, if your client has those restrictions, as a Flash Developer, you’re stuck with these limitations and, usually, no amount of “hey, but look at how much more elegant my code is if i break the SWF up into several pieces” will help .

Anyways, here’s the AS2 code:

import com.greensock.*;
import com.greensock.easing.*;
import com.greensock.plugins.*;

TweenPlugin.activate([BlurFilterPlugin]);

var tweenSpeed1:Number = 2;
var blurYamount1:Number = 60;
var noBlur:Number = 0;

//init blur filter & position on hidden asset
TweenLite.to(couple1, 0, {delay:0, _y:200, blurFilter:{blurY:blurYamount1}});
TweenLite.to(couple2, 0, {delay:0, _y:200, blurFilter:{blurY:blurYamount1}});

//remove blur as the hidden asset animates onto the stage
TweenLite.to(couple1, tweenSpeed1-1, {delay:2, blurFilter:{blurY:noBlur}, _y:0, overwrite:false});

//move the asset off stage, as per storyboard, blur it again, as you move it
TweenLite.to(couple1, tweenSpeed1, {delay:4, blurFilter:{blurY:blurYamount1}, _y:200, ease:Elastic.easeOut, overwrite:false});

//remove blur as the hidden asset animates onto the stage
TweenLite.to(couple2, tweenSpeed1-1.25, {delay:4.5, blurFilter:{blurY:noBlur}, _y:10, overwrite:false});

//move the asset off stage, as per storyboard, blur it again, as you move it
TweenLite.to(couple2, tweenSpeed1, {delay:7, blurFilter:{blurY:blurYamount1},_y:200, ease:Elastic.easeOut, overwrite:false});