ActionScript: Flecha que se estira (AS 3.0)

Autor: Francisco Arce
Correo: fj_arce@yahoo.com.mx


Esta basado en el algorito para una lineaque se estira. Aqui el chiste es dibujar la punta de la flecha y hacer que gire en el mismo ángulo que tenga la línea. Para obtener este ángulo, contamos con los puntos de la linea (el inicial y el final) y calculamos el arco tangente, el cual nos regresa el angulo en radianes. Los convertimos a grados y aplicamos la propiedad rotación. Acuerdate que los angulos en FLash estan desplazados 90 grados , por lo que ajustamos el mismo.

Como siempre se calcula la linea y la punta solo se rota, no hay distorsión. El código de la clase Flecha es el siguiente:

package {
   import flash.display.Sprite;
   import flash.events.MouseEvent;
   import flash.utils.Timer;
   import flash.events.TimerEvent;

   public class Flecha extends Sprite {
      var flecha:Sprite = new Sprite();
      var tiempo:Timer = new Timer(60,0);
      var contenedor:Sprite;
      var cuadro1:Sprite;
      var cuadro2:Sprite;
      var ancho:uint=10;
      var alto:uint=15;
      var x1:int=0;
      var y1:int=0;
      var x2:int=100;
      var y2:int=100;
      var color:uint=0;

      public function Flecha(xx,yy,lon,color):void {
      //Sujetador
      this.color=color;
      this.x1=xx;
      this.y1=yy;
      this.x2=xx+lon;
      this.y2=yy;
      //
      flecha.graphics.beginFill(0,.7);
      flecha.graphics.moveTo(-(ancho/2),-alto);
      flecha.graphics.lineTo(ancho/2,-alto);
      flecha.graphics.lineTo(0,0);
      flecha.graphics.lineTo(-(ancho/2),-alto);
      //
      addChild(flecha);
      flecha.x=x2;
      flecha.y=y2;
   //
   //Calcula segmentos
   var dx:Number=x1-x2;
   var dy:Number=y1-y2;

   //Determina el ángulo y lo convierte
   var radianes:Number=Math.atan2(dy,dx);
   var grados = 360*(radianes/(2*Math.PI));

   // point at cursor
   flecha.rotation=grados+90;
   //
   cuadro1=new Sprite ;
   cuadro1.graphics.beginFill(0xffffff);
   cuadro1.graphics.lineStyle(1,0,1);
   cuadro1.graphics.moveTo(0,0);
   cuadro1.graphics.lineTo(0,5);
   cuadro1.graphics.lineTo(5,5);
   cuadro1.graphics.lineTo(5,0);
   cuadro1.graphics.lineTo(0,0);
   //Sujetador 2
   cuadro2=new Sprite ;
   cuadro2.graphics.beginFill(0xffffff);
   cuadro2.graphics.lineStyle(1,0,1);
   cuadro2.graphics.moveTo(0,0);
   cuadro2.graphics.lineTo(0,5);
   cuadro2.graphics.lineTo(5,5);
   cuadro2.graphics.lineTo(5,0);
   cuadro2.graphics.lineTo(0,0);
   //
   contenedor=new Sprite ;
   contenedor.graphics.lineStyle(2,color,.7);
   contenedor.graphics.moveTo(x1,y1);
   contenedor.graphics.lineTo(x2,y2);
   //contenedor.x=xx;
   //contenedor.y=yy;
   addChild(contenedor);
   addChild(cuadro1);
   addChild(cuadro2);
   //
   cuadro1.x=x1-2.5;
   cuadro1.y=y1-2.5;
   cuadro2.x=x2-2.5;
   cuadro2.y=y2-2.5;
   //
   cuadro1.addEventListener(MouseEvent.MOUSE_DOWN, onMueveCuadro1);
   cuadro2.addEventListener(MouseEvent.MOUSE_DOWN, onMueveCuadro1);
   //
   cuadro1.addEventListener(MouseEvent.MOUSE_UP, onMueveCuadro2);
   cuadro2.addEventListener(MouseEvent.MOUSE_UP, onMueveCuadro2);
   }

   function onMueveCuadro1(e:MouseEvent):void {
      e.target.startDrag();
      tiempo.start()
      tiempo.addEventListener(TimerEvent.TIMER, onPintaLinea);
      //trace("inicio",e.target.name,e.target.x, e.target.y);
   }

   function onMueveCuadro2(e:MouseEvent):void {
      //trace("fin", e.target.name, e.target.x, e.target.y);
      e.target.stopDrag();
      tiempo.stop();
      pintaLinea();
   }

   function onPintaLinea(e:TimerEvent):void {
      pintaLinea();
   }

   function pintaLinea() {
      //
      //Calcula segmentos
      var dx:Number=cuadro1.x-cuadro2.x;
      var dy:Number=cuadro1.y-cuadro2.y;
      //
      //Determina el ángulo y lo convierte
      var radianes:Number=Math.atan2(dy,dx);
      var grados = 360*(radianes/(2*Math.PI));
      flecha.rotation=grados+90;
      flecha.x = cuadro2.x+2.5;
      flecha.y = cuadro2.y+2.5;
      //
      this.removeChild(contenedor);
      contenedor=new Sprite ;
      contenedor.graphics.lineStyle(2,color,1);
      contenedor.graphics.moveTo(cuadro1.x+2.5,cuadro1.y+2.5);
      contenedor.graphics.lineTo(cuadro2.x+2.5,cuadro2.y+2.5);
      addChild(contenedor);
      swapChildrenAt(3, 0);
   }
}
}

http://www.pacoarce.com

¿Qué diablos es una función? ActionScript 3.0

Funciones

Las funciones en AS3.0 tienen nuevas características importantes para la programación orientada a objetos. En general tenemos en ActionScript tres tipos de funciones: Funciones globales, métodos (o funciones relacionadas a un objeto) y funciones hechas por el usuario.
Las funciones las podríamos definir como grupos de sentencias que tienen un fin específico. Pueden o no regresar un valor. También podemos mandarles valores a las mismas (llamados argumentos o parámetros), pero también tendremos funciones sin parámetros.

Funciones globales

Las funciones globales están incorporadas a Flash, y pueden ser llamadas en cualquier parte del programa  Por ejemplo, la función trace(), se puede utilizar en cualquier sin definir un objeto y en cualquier momento. Otras funciones globales son las puede consultar en la ayuda del paquete.

Métodos

Los métodos son funciones que están asociadas a una clase. Existen métodos, de las clases predefinidas, en que los utilizamos por medio de la notación punto, por ejemplo:
Math.random()
En la programación orientada a objetos, y por lo tanto en AS3.0, es muy común que el programador genere sus propios métodos, añadiendo funciones a las clases hechas por el usuario. De hecho al hacer un constructor, estamos escribiendo una función.

Funciones personalizadas

Aunque en AS3.0 los usuarios también hacen funciones dentro de clases, llamaremos funciones personalizadas aquellas que se definen fuera de la clase. Dentro del paquete las llaman function clausures o cierre de función.

Llamado o invocación de una función

Para llamar a una función se utiliza su identificador, seguido de los paréntesis. Si la función requiere de parámetros o de argumentos, estos van dentro de los paréntesis, divididos por comas. Por ejemplo, nuestra ya conocida función global trace() requiere de un parámetro:
trace(“Hola Mundo”);
Existen parámetros que son requeridos y otros que son opcionales. Por ejemplo, si escribe una función trace() sin argumentos, el compilador le enviará un mensaje de error.
Si la función no requiere parámetros, con escribir los paréntesis vacíos es suficiente. De hecho, si una función global no requiere argumentos, puede escribirla sin paréntesis, pero a esto se le considera una mala práctica de programación.

Funciones de usuario

Existen dos formas de definir una función en ActionScript 3.0: por una sentencia de función o por una expresión de función. Las características de las mismas se presentan a continuación:

Función tipo sentencia

Este estilo de codificar funciones (también conocido extraoficialmente como codificación estilo Flash 5, porque en aquellos lejanos tiempos era la única forma) son la forma más adecuada de definir variables cuando se trabaja en con el compilador en modo estricto.
Este modo tiene la siguiente sintaxis:
function nombreFuncion(arg1, arg2,…){
}
Primero va la palabra reservada function, seguido del identificador de la función. Entre paréntesis van los argumentos (si existen), y después las llaves, que forman el cuerpo de la función.

Funciones tipo expresiones

También conocida como función literal o anónima. Extraoficialmente se le conoce como tipo de codificación Flash MX, porque en esta versión apareció.
Su sintaxis es:
var nombreFunción:Function = function (arg1, arg2,…){
}
Nota: En general debe considerarse usar las funciones de sentencia, pues son más fáciles de leer y el compilador detecta de mejor manera cualquier problema que se encuentre en ellas. Las funciones de sentencia (tipo Flash 5) existen en todo el ámbito en que están definidas. Las funciones de expresión deben ser definidas antes de ser utilizadas.

Funciones que regresan valores

Para regresar un valor de una función, al igual que las versiones anteriores de AS, utilizamos la palabra reservada return. Todas las sentencias que se encuentren debajo del return ya no son procesadas, pues con esta sentencia termina la función. En el modo estricto del compilador, la función debe de regresar el mismo tipo de dato con la cual fue definida, por ejemplo:
function cuadrado(num:int):int {
            return num*num;
}
Para indicarle al compilador el tipo de dato de regreso, se debe escribir el signo de dos puntos (:) entre el paréntesis que cierra los argumentos y la llave que abre el cuerpo de la función. Los tipos deben de ser los mismos que los tipos de datos ya revisados.
Si la función no regresa ningún valor, y quiere que el compilador en modo estricto lo detecte, debe utilizar la palabra reservada void. A diferencia que en las versiones anteriores, la palabra void se escribe toda en minúsculas.

Funciones anidadas

Es posible anidar funciones, es decir, poner una o más funciones dentro de otra. Las funciones anidadas no van a poder ser acezadas fuera de la función que las contiene, a menos que sean llamadas por “referencia”, término que analizaremos más adelante.

Ejercicio

• Abra un archivo Flash ActionScript 3.0 y guárdelo como funciones.fla en su carpeta de trabajo.
• Abra un archivo ActionScript y guárdelo como Funciones.as en la carpeta misClases.
• Ligue a ambos archivos en el campo Document Class.
• Asegúrese de que se encuentra e modo estricto del compilador.
• En el archivo de clase escriba el siguiente guión:

package misClases{
            import flash.display.Sprite;
            public class Funciones extends Sprite {
                        public function Funciones() {
                                    trace(junta("tuNombre","tuApellido"));
                        }
                        public function junta(arg1:String,arg2:String):String {
                                    function nombre(arg3:String):String {
                                                return arg3;
                                    }
                                    public apellido(arg4:String):String {
                                                return arg4;
                                    }
                                    return nombre(arg1) +" "+apellido(arg2);
                        }
            }
}

• Ahora intente llamar a la función apellido() desde la función constructora. El compilador deberá enviarle un mensaje de error.

http://www.pacoarce.com

Características del DataGrid en Flex ActionScript 3.0

1. Columnas ajustables 
2. Columnas y encabezados personalizables
3. Las celdas pueden ser editables 
4. Selección múltiple 
5. Los datos desplegados pueden ser personalizados 
6. Paginación de datos 

Ejemplo de un DataGrid 

<mx:DataGrid columns="No default." dataProvider="No default." sortableColumns="true|false" . . . />

Cargar datos a un DataGrid

Los datos se cargan a un DataGrid por medio de la propiedad dataProvider.

La mejor manera de cargar datos es por medio de un ArrayCollection.

Es necesario importar la clase: 

mx.collections.ArrayCollection

Cargar con datos a un DataGrid

Ejemplo para poblar un DataGrid desde un modelo de datos:

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/ 2006/mxml" xmlns="*"
layout="absolute" creationComplete="restaurants = new ArrayCollection(myDataModel.item)">

<mx:Model id="myDataModel">
<item>
<key>0</key>
<style>Thai</style>
<number>6</number>
</item>
<item>
<key>1</key>
<style>Indian</style>
<number>14</number>
</item>
</mx:Model>

<mx:Script>
<![CDATA[
import mx.collections.ArrayCollection;

[Bindable]

public var restaurants:ArrayCollection;

]]>

</mx:Script>
<mx:DataGrid dataProvider="{restaurants}"/>

</mx:Application>

• Una columna es creada para cada propiedad
• El orden de las columnas no es previsible
• El nombre de las columnas por omisión es el nombre de la propiedad

Ejemplo de la carga de un control dataGrid desde un archivo XML

http://www.youtube.com/watch?v=9DUYoK8poTo

http://www.youtube.com/watch?v=RyNf5r65yXE

Básico como armar un layout con Canvas

Más sobre Canvas y estados

http://www.youtube.com/watch?v=IdM_rgDaVM0

http://www.youtube.com/watch?v=6OzHK58XSfA

Dibujar una nave sencilla con el API (AS 3.0)

Autor: Francisco Arce
Correo: fj_arce@yahoo.com.mx


Cuando hacemos juegos con ActionScript 3.0, es muy útil dibujar una nave sencilla con el API de dibujo, pues no necesitamos cargar ninguna imagen y resulta extremadamente ligera. A continuación mostramos en código de una clase llamad Nave que realiza este dibujo:

package {
   import flash.display.Sprite;

   public class Nave extends Sprite {
      public function Nave() {
         init(false);
      }
      public function init(llama:Boolean):void {
         graphics.clear();
         graphics.lineStyle(1,0);
         graphics.moveTo(10,0);
         graphics.lineTo(-10,10);
         graphics.lineTo(-5,0);
         graphics.lineTo(-10,-10);
         graphics.lineTo(10,0);

         if (llama) {
            graphics.moveTo(-7.5,-5);
            graphics.lineTo(-15,0);
            graphics.lineTo(-7.5,5);
         }
      }
   }
}   

http://www.pacoarce.com
         

ActionScript 3.0: Cursor personalizado

Autor: Francisco Arce
Correo: fj_arce@yahoo.com.mx

function pintaColor(e:MouseEvent):void {
   var color:String = e.target.name;  
   Mouse.hide();
   pincel_mc = new Pincel();
   addChild(pincel_mc);
   stage.addEventListener(Event.ENTER_FRAME, cursorPincel);
}

function cursorPincel(event:Event):void {
   pincel_mc.mouseEnabled = false;
   pincel_mc.x = mouseX;
   pincel_mc.y = mouseY;
} 

http://www.pacoarce.com

ActionScript 3.0: Cambio color

Una aplicación clásica en los desarrollos educativos es que el usuario (por lo general un niño) iluminen un dibujo. Hay muchas maneras de hacerlo. Una forma de solucionar este problema es tener el dibujo dvidido en diferentes movie clips blancos y un gráfico con los contornos del dibujo.

Es importante nombrar a cada uno de los clips con nombres diferentes. Por lo general necesitamos hacer "grupos" de varios pedazos del dibujo, por ejemplo las manos, el cuello y la cara van del mismo color. También necesitaremos botoncitos que representen los diferentes botones para que el usuario seleccione el color. Por lo general utilizamos un cursor personalizado, ya sea un pincel o una brocha.

Para poder cambiar el movie clip, necesitamos un objeto intermedio donde almacenaremos el color, en este caso necesitamos un objeto ColorTransform. Dicha clase se encuentra en el paquete geom, y este a su ves en el paquete flash. Recuerda que si codificas en la línea de tiempo, no es necesario importar las clases del paquete flash, pero si trabajas en clases, tienes que importarla:

import flash.geom.ColorTransform;

Así que crea un objeto de tranformación de color, donde almacenaremos el color que haya seleccionado el usuario:

var colorInfo:ColorTransform;

Aqui almacenamos el color (en formato hexadecimal, de preferencia). Supongamos que desamos cambiar el color a amarillo:

colorInfo = new ColorTransform();
colorInfo.color = 0xffff00;

Ahora aplicamos este cambio al movie clip (digamos que se llama dibujo) con la siguiente asignación:

dibujo.transform.colorTransform = colorInfo;

Listo, el movie clip cambiará de color. Hay que remarcar que si el movie clip tiene un degradado o diferentes colores que los aplicamos en tiempo de autor ed decir, con el EDI, los colores se remplazarán por el color que aplicamos.

http://www.pacoarce.com

¿Qué diablos es un ciclo o bucle?

Bucles

Una sentencia bucle puede repetir un grupo de sentencias controladas con una o más expresiones. Las instrucciones que se ejecutarán, van encerradas entre llaves. Opcionalmente se pueden omitir las llaves, pero es una práctica no recomendada. Las sentencias de bucles incluidas en AS3.0, son las siguientes:

Sentencia for

Una sentencia for se utiliza cuando se conoce el número de interacciones que se busca. Cuenta con tres elementos: una asignación inicial. Se le conoce como valor inicial. Después una condición de control, la cual se ejecutará mientras su resultado sea verdadero.  Cuando esta condición sea falsa el bucle terminará. Por último una operación que cambia de valor a la variable de control o índice (generalmente es un incremento, pero puede ser un decremento). Los elementos del bucle se separan con punto y coma. Su sintaxis es:
for(var i:int =0; i<10; i++){
            trace(i);
}

Sentencia for..in

Este bucle sirve para recorrer objetos y arreglos. Tiene dos parámetros. El primero nos traerá en nombre de la propiedad. El segundo es el nombre del objeto o arreglo que queramos analizar. Su sintaxis es:
for(param in objeto){
            trace(param+”-> “+objeto[param]);
}
Si se quiere analizar un arreglo, su sintaxis es:
for(param in arreglo){
            trace(arreglo[param]);
}
Observe que en medio de los parámetros, va la palabra reservada in. Los objetos guardan sus parámetros sin un orden predeterminado.

Sentencia for each.. in

Esta sentencia recorre los elementos de una colección, que puede estar formada por las etiquetas de un objeto XML o XMLList, los  valores de las propiedades de un objeto o los elementos de un arreglo. Por ejemplo, como se indica en el siguiente fragmento, se puede utilizar una sentencia for each..in para recorrer un objeto genérico, pero a diferencia del bucle for..in, la variable de iteración contiene el calor de la propiedad en lugar del valor de la misma.

Sentencia while

La sentencia while se utiliza cuando no se sabe el número de interacciones que se necesitan. Hay que tener cuidado en no caer en un bucle infinito (que no tiene salida y se repite indefinidamente). Para ello contamos con la sentencia break, que corta el ciclo. También puede utilizarse en forma controlada como un for, por ejemplo:
var i:int = 0;
while(i<5){
            trace(i);
i++;
}
Para que experimente lo que es un bucle infinito, borre la sentencia i++. El compilador le enviará un mensaje con el cual podrá suspender el mismo en aproximadamente 15 segundos.

Sentencia do..while

La sentencia do..while es muy similar a la anterior, con la diferencia que el bloque de instrucciones se ejecutará al menos una vez. Por lo general se utiliza cuando no sabemos el número de interacciones que buscamos. Al igual que la sentencia anterior, hay que tener cuidado para no caer en bucles infinitos. Un ejemplo controlado de la sentencia do..while, que simula a una sentencia for, es la siguiente:
var i:int = 0;
do{
            trace(i);
            i++;
} while (i<5);

http://www.pacoarce.com

ActionScript 3.0: Simular gravedad, hacer rebotar una pelota

Autor: Francisco Arce
Correo: fj_arce@yahoo.com.mx

Dentro de los juegos y animaciones, es muy utilizado la simulación del mundo real por medio de un poco de matemáticas. A eso lo conocemos como "Physics". Dentro de este ramo, simular la gravedad de un objeto es básica. Aqui les dejo una sutina en ActionScript 3.0 para simular el rebote de una pelotita.

Saludos :)

 stage.addEventListener(MouseEvent.CLICK, onClick);
var dy = 20;
var dx = 5
var topey = bola.y;
var topex = bola.x
var gravedad = 1.5;

function onClick(e:Event):void {
   dy = 20;
   addEventListener(Event.ENTER_FRAME, onSalta);
}

function onSalta(e:Event):void {
   bola.x += dx;
   bola.y -= dy
   dy -= gravedad
   if (bola.y > topey) {
      bola.y = topey;
      removeEventListener(Event.ENTER_FRAME, onSalta);
   }
   if (bola.x > stage.stageWidth) {
      bola.x = topex;
   }
}  

http://www.pacoarce.com

Crear una clase con métodos estáticos con ActionScript 3.0

Durante los proyectos, muchas veces es necesario tener rutinas (por lo general de validación) que las podemos utilizar como una caja de herramientas en cualquier función. Por ejemplo, validar las direcciones de correo, fechas, calcular edades, limpiar cadenas, llenar números con ceros, con muchas otras opciones.

Para ello es mejor hacer una clase y declarar a cada una de las funciones como públicas y estáticas. En actionScript tenemos muchas funciones estáticas, como Math, Print, etc.

También podemos almacenar variables "globales", las cuales pueden ser llamadas desde cualquier otra clase:

package com.misclases
{
    public class Aux
    {
        public static var idioma:String = "Español";
    }
}

Hasta el momento, no se crea la clase "estática", sino las propiedades y los métodos:

package  com.dysport{

public class Aux {

public function Aux() {
// constructor code
}

public static function ceros(cadena,num):String{
var l = cadena.length;
cadena = cadena.replace(" ","");
for(var i=0; i<(num-l); i++){
cadena = "0"+cadena;
}
return cadena;
}
public static function validaFecha(d, m, a){
var hoy = new Date();
//trace(d, m, a);
var dd = Number(d);
var mm = Number(m);
var aa = Number(a);
var diasMes = new Array();
//No es numerico
if(isNaN(dd)) return false;
if(isNaN(mm)) return false;
if(isNaN(aa)) return false;
//
if(a<1900) return false;
if(a>hoy.getFullYear()+1) return false;
//
var febrero = (((aa % 4 == 0) && ( (!(aa % 100 == 0)) || (aa % 400 == 0))) ? 29 : 28 );
//
for (var i = 1; i <= 12; i++) {
diasMes[i] = 31;
if (i==4 || i==6 || i==9 || i==11) diasMes[i] = 30;
if (i==2) diasMes[i] = febrero;
}
if(dd>diasMes[mm]) return false;
return true;
}
}
}

Estas clases pueden ser llamadas, una vez importada la clase, por ejemplo

Aux.ceros(numéro, 2);
Aux.validaFecha(10,10,1966);
trace(Aux.idioma);

http://www.pacoarce.com

ActionScript: Un objeto que se mueva en el sentido del cursor

Autor: Francisco Arce
Correo: fj_arce@yahoo.com.mx


package  {
   import flash.display.Sprite;
   import flash.events.Event;

Desde ActionScript es fácil hacer que un movieclip siga al cursor:

   public class Bola extends Sprite{
      var dx:int = 0;
      var atenuacion:Number = .10
      var margen:int = 30;

      public function Bola() {
         addEventListener(Event.ENTER_FRAME, onMueve)
      }

      private function onMueve (e:Event):void {
         this.x += dx;
         dx = (stage.mouseX - stage.stageWidth/2) * atenuacion;
         if (this.x stage.stageWidth - margen) {
            this.x = stage.stageWidth - margen
         }
      }
   }
}

http://www.pacoarce.com

Insertar un registro en la base de datos con Adobe AIR

Para insertar un registro en una tabla, debe tener (obviamente) creada la base, la tabla y tener una conexión a la base de datos. Una vez realizada la conexión, deberá crea un objeto de la clase SQLStatement, la cual contiene la cadena del query a realizarse. El resultado exitoso se detecta con el evento SQLEvent.RESULT y el intento erróneo con SQLErrorEvent.ERROR.

El query se ejecuta con el método execute()

Para insertar hay que ejecutar un comando INSERT , pero lo parámetros se escriben con dos puntos (:) Los valores de los mismos se pasan con la propiedad "parameters". Es muy recomendable limpiar los parametros con el método clearParameters() para estar seguros de limpiar los mismos.

EJEMPLO:

var fecha:Date = new Date()
var query:SQLStatement = new SQLStatement();
query.sqlConnection=conn;
var queryText = "INSERT INTO 'registro' "+
"(id, usuario, libro, bloque, unidad, leccion, actividad, fecha, hora, accion) "+
" VALUES(:id, :usuario, :libro, :bloque, :unidad, :leccion, :actividad, :fecha, :hora, :accion)";
query.clearParameters();
query.parameters[":id"] = 0;
query.parameters[":usuario"] = usuario;
query.parameters[":libro"] = libro;
query.parameters[":bloque"] = bloque;
query.parameters[":unidad"] = unidad;
query.parameters[":leccion"] = leccion;
query.parameters[":actividad"] = actividad;
query.parameters[":fecha"] = fecha.fullYear+"/"+(fecha.month+1)+"/"+fecha.date;
query.parameters[":hora"] = fecha.hours+":"+fecha.minutes+":"+fecha.seconds;
query.parameters[":accion"] = accion;
//
query.text = queryText;
//
try {
   query.execute();
}
   catch(error:SQLError){
   trace("Error: " + error.toString());
}

http://www.pacoarce.com

Dibujar una flecha con ActionScript 3.0

Autor: Francisco Arce
Correo: fj_arce@yahoo.com.mx


Es util dibujar una flecha con el API de dibujo sin necesidad de las herramientas de EDI,

package {<br />
   import flash.display.Sprite;
    public class Arrow extends Sprite {<br />
    public function Arrow() {<br />
       init();<br />
    }<br /><br />
    private function init() {<br />
            graphics.lineStyle(1,0,1);<br />
            graphics.beginFill(0xffff00);<br />
            graphics.moveTo(-50,-25);<br />
            graphics.lineTo(0,-25);<br />
            graphics.lineTo(0,-50);<br />
            graphics.lineTo(50,0);<br />
            graphics.lineTo(0,50);<br />
            graphics.lineTo(0,25);<br />
            graphics.lineTo(-50,25);<br />
            graphics.lineTo(-50,25);<br />
            graphics.lineTo(-50,-25);<br />
            graphics.endFill();<br />
    }<br />
  }<br />
}

http://www.pacoarce.com

Tipo de columnas MySQL

Como ya se había dicho, una tabla es un conjunto de uno o más columnas. Cuando se crea una tabla con la sentencia CREATE TABLE, se especifica el tipo deseado para cada columna. Un TIPO DE COLUMNA es más específico que un TIPO DE DATO. El tipo de dato es una categoría general como "número"o "cadena". A un tipo de cadena le caracteriza precisamente la clase de valores que puede contener, como SMALLINT o VARCHAR(32).

            Los tipos de columna MySQL son los responsables de describir qué clase de valores quiere que contenga una columna, lo que determina a su vez la manera en que MySQL tratará dichos valores. Cada tipo de columna tiene varias características:

·                Qué clase de valores quiere almacenar.

·                Cuánto espacio ocupan los valores, si son de longitud fija o de longitud variable.

·                Cómo se clasifican o comparan los valores del tipo.

·                Si el tipo permite o no valores NULL

·                Si el tipo se puede indexar o no

Comprender los tipos de columna es muy importante para reducir el tamaño de la base de datos y aumentar su velocidad de los procesos.

MySQL proporciona tipos de columna para todas las categorías de valores de datos en general, excepto para el valor NULL.

Tipo de columna entera

Para números enteros (que no tienen parte fraccional), como 43, -1, 3, 0 o -789345, los formatos que MySQL puede manejar son:

Nombre del tipo            Significado                        Rango

TINYINT                        Entera muy pequeña            Con signo -128 a 127

                                    Requiere 1 byte                        Sin signo 0 a 255

SMALLINT                        Entera pequeña                        Con signo -32768 a 32767

                                    Requiere 2 bytes            Sin signo 0 a 65535

MEDIUNMINT                        Entera mediana                        Con signo -8388608 a 8388607

                                    Requiere 3 bytes            Sin signo 0 a 1677215

INT                                    Entera estándar                        Con signo -2147683648 a 2147483647

                                    Requiere 4 bytes            Sin signo 0 a 4,294,967,295

BIGINT                                    Entero muy grande            Con signo -9223372036854775808 a

                                    Requiere 8 bytes                            9223372036854775807

                                                                        Sin signo 0 a 18,446,744,073,709,551,615

Observe que el rango de los cinco tipos de enteros depende de si tiene o no signo (UNSIGNED), que es uno de los atributos. Un ATRIBUTO es una característica adicional a la columna. Para seleccionar algún tipo de columna necesitamos analizar el rango de nuestra información y seleccionar el tipo más pequeño que satisfaga ese rango, de lo contrario estaremos desperdiciando recursos de nuestra base de datos.

Por ejemplo, si tenemos un campo que almacenará la edad de una persona (entre 0 y 120 años) nos funciona perfectamente la columna tipo TINYINT. Si se utilizara para este campo un tipo de columna como INT (con 4 bytes), en realidad está desperdiciando 3 bytes. Si su base de datos es grande, por ejemplo, la población de un municipio con 100,000 habitantes, usted está desperdiciando en un solo campo 300,000 bytes.

Si usted intenta almacenar un campo mayor al rango del tipo de columna, el proceso marcará un error y solo cargará hasta el rango máximo, por ejemplo: Tiene un campo tipo TINYINT con signo, y almacena un valor como 500, solo se almacenará 127.

http://www.pacoarce.com
 

¿Qué diablos es una sentencia condicional?

Sentencias condicionales

En AS3.0 contaremos con tres sentencias, las cuales no sufrieron cambios de las versiones anteriores:

Sentencia if

La sentencia if efectuará una verificación de una expresión con resultado booleano (true/false). Si la condición resulta verdadera, efectuará un bloque de sentencias. Su sintaxis es:
if(condición){
            sentencia1…
            sentencia2…
            etcétera…
}

Opcionalmente puede tener una sentencia else, la cual agrupa las sentencias que se ejecutarán si la condición da como resultado un valor false, La sentencia else siempre tiene que ir precedida de un if. Su sintaxis es:

if(condición){
            sentencia1…
            sentencia2…
            etcétera…
} else {
            sentencia1…
            sentencia2…
            etcétera…
}

Sentencia if.. else if

Si necesita verificar varias condicionales se puede utilizar la sentencia if… else if…
La última sentencia if, puede llevar su contraparte else, la cual se ejecutará si no se cumple ninguna de las anteriores. Digamos que desea tomar diferentes decisiones dependiendo de la edad del usuario:
if(edad<18){
            trace(“Usted no puede acceder el portal”);
} else if(edad<25){
            trace(“Solo tiene acceso a ciertas paginas de nuestro portal”);
} else if(edad<40){
            trace(“Usted tiene acceso completo a nuestra información”);
} else {
            trace(“Lo sentimos, su edad rebasa el limite de nuestra página”);
}

Sentencia switch()

Una sentencia switch puede sustituir a una estructura if… else if… Con la diferencia en que en ves de un resultado booleano, regresará un valor con el cual tomará las decisiones. Si se cumple la condición se ejecutarán las sentencias hasta encontrar la sentencia break, incluso si hay otras condiciones. Si ninguna de las condiciones se cumplen, se ejecutará el bloque de sentencias después de la sentencia default (la cual es opcional). Su sintaxis es:
switch(numVidas){
            case 8:
                        trace(“Felicidades, estás enterito”),
                        break;
            case 7:
            case 6:
            case 5:
                        trace(“Vas muy bien, aun puedes superar la prueba”);
                        break;
            case 4:
            case 3:
                        trace(“Ups, necesitas esforzarte más”);
                        break;
            case 2:
            case 1:
                        trace(“Vamos, estás a punto de perder el juego!”);
break;
            default:
                        trace(“Lo sentimos, vuelve a intentarlo”);
}
Enlaces de interés:
http://www.youtube.com/watch?v=xUOtWcHj-bk

http://www.pacoarce.com

Modificar las columnas de un data Grid con Adobe AIR

Uno de los controles más utilizados en el desarrollo de aplicaciones con AIR, Flash y Flex es el data Grid. Esta herramienta es aún más poderosa al momento de manipular las columnas por medio de la clase DataGridColumn. Para ello puede importar las siguientes tres clases que se muestra a continuación:

import fl.data.DataProvider;
import fl.controls.DataGrid;
import fl.controls.dataGridClasses.DataGridColumn;

Por ejemplo, una vez abierta una bas de datos, podemos leer una tabla y vaciarla en un datagrid de la siguiente forma:

function onQueryLeeTabla (e:SQLEvent) {
var q:SQLStatement=e.target as SQLStatement;
var r:SQLResult=q.getResult();
        //
var dp:DataProvider = new DataProvider();
//
datos_dg.addColumn(new DataGridColumn("Fecha"));
datos_dg.addColumn(new DataGridColumn("Cliente"));
datos_dg.addColumn(new DataGridColumn("Correo"));
datos_dg.addColumn(new DataGridColumn("Confirmada"));
//
datos_dg.dataProvider = dp;
datos_array = new Array();
datos_dg.dataProvider.removeAll();
for each (var o:Object in r.data) {
var obj:Object = new Object();
obj.Fecha = o.fecha;
obj.Cliente = o.cliente;
obj.Correo = o.correo;
obj.Confirmada = o.confirmada;
datos_dg.addItem(obj);
datos_array.push(o);
  reg++;
}
if(reg==0){
mensaje_txt.text = "No hay registros en la tabla";
} else {
//datos_dg.addEventListener(Event.CHANGE, onSelecciona);
//mensaje_txt.text = "Selecciona un registro";
}
}

Cursos gratuitos de programación web en: http://www.pacoarce.com

El DataGrid en Flex

Ejemplo de un DataGrid

<mx:DataGrid columns="No default." dataProvider="No default." sortableColumns="true|false" . . . />

Cargar datos a un DataGrid

Los datos se cargan a un DataGrid por medio de la propiedad dataProvider.

La mejor manera de cargar datos es por medio de un ArrayCollection.

Es necesario importar la clase:


mx.collections.ArrayCollection

Cargar con datos a un DataGrid

Ejemplo para poblar un DataGrid desde un modelo de datos:

<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/ 2006/mxml" xmlns="*"
layout="absolute" creationComplete="restaurants = new ArrayCollection(myDataModel.item)">

<mx:Model id="myDataModel">
<item>
<key>0</key>
<style>Thai</style>
<number>6</number>
</item>
<item>
<key>1</key>
<style>Indian</style>
<number>14</number>
</item>
</mx:Model>

<mx:Script>
<![CDATA[
import mx.collections.ArrayCollection;

[Bindable]

public var restaurants:ArrayCollection;

]]>

</mx:Script>
<mx:DataGrid dataProvider="{restaurants}"/>

</mx:Application>


Una columna es creada para cada propiedad

El orden de las columnas no es previsible

El nombre de las columnas por omisión es el nombre de la propiedad

Más información: http://www.pacoarce.com

ActionScript 3.0: Pasar parámetros a una película en ActionScript 3.0

Autor: Francisco Arce
Correo: fj_arce@yahoo.com.mx
Fecha: 20110222
 
Si deseas pasar código a una película AS 3.0 necesitamos un objeto de la clase LoaderInfo, el cual proporciona información sobre un objeto visual (display objet) ya sea una película swf o un archivo de imagen.

Para obtener información de un objeto LoaderInfo existen dos maneras;

• Por la propiedad loaderInfo de los objetos visuales
• Por la propiedad contentLoaderInfo de un objeto Loader.

Si deseas extraer la información de estos objetos, necesitamos la propiedad parameters. Según el manual:

"Las dos fuentes de parámetros son: la cadena de consulta de la URL del archivo SWF principal y el valor del parámetro HTML FlashVars (éste sólo afecta al archivo SWF principal)."

Por HTML (flashVars) o llamando al archivo SWF desde la URL (método GET).
Se puede utilizar las siguientes instrucciones:

var parametros:Object = LoaderInfo(this.root.loaderInfo).parameters;

O leerlo directamente com:

var miParametro = LoaderInfo(this.root.loaderInfo).parameters.parametro;

También se puede aceptar:

var titulo = MovieClip(this.root).loaderInfo.parameters.titulo;

Observe que this.root es la película principal. Un buen tutorial de uso de flashVars es el siguiente:

http://blogs.adobe.com/pdehaan/2006/07/using_flashvars_with_actionscr.html
http://gotoandlearn.com/play.php?id=77

Alimentar diferentes listas en forma dinámica con Adobe AIR

Una aplicación muy frecuente para la explotación de información de una base de datos, es leer una tabla y armar diferentes listas o combo box para después seleccionar los datos. Una vez ye tenemos los datos leídos, por medí de un ciclo y de diferentes sentencias condicionales, generamos un arreglo para cada características, llenamos las listas y esperamos a que el usuario seleccione el criterio para consultar los datos de las tablas.

En la siguiente función, seleccionaremos los correos de los criterios seleccionados y los enviaremos al protocolo malito, para generar un correo electrónico con el agente de correo de la computadora.

private function cargaComponentes(){
var meses_array:Array = new Array("","Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio", "Julio", "Agosto", "Septiembre", "Octubre", "Noviembre", "Diciembre");
contacto_array = new Array();
genero_array = new Array;
edad_array = new Array;
fecha_array = new Array;
//
var i,j,genero,edad,fecha;
//
for(i=0; i<datos_array.length; i++){
contacto_array.push({label:datos_array[i].nombres, data:datos_array[i].rfc});
//genero
for(j = 0; j<genero_array.length; j++){
if(genero_array[j].label==datos_array[i].genero){
break;
}
}
if(j==genero_array.length){
genero = (datos_array[i].genero=="M")?"Masculino":"Femenino";
genero_array.push({label:genero, data:datos_array[i].genero});
}
//Edad
for(j = 0; j<edad_array.length; j++){
if(edad_array[j].label==datos_array[i].edad){
break
}
}
if(j==edad_array.length){
edad_array.push({label:datos_array[i].edad, data:datos_array[i].edad});
}
//Fecha
fecha  = datos_array[i].diaNacimiento+" de ";
fecha += meses_array[Number(datos_array[i].mesNacimiento)]+" de ";
fecha += datos_array[i].anioNacimiento;
datos_array[i].fecha = fecha;
for(j = 0; j<fecha_array.length; j++){
if(fecha_array[j].label==fecha){
break
}
}
if(j==fecha_array.length){
fecha_array.push({label:fecha, data:fecha});
}
}
contacto_array.sort();
edad_array.sortOn("label", Array.NUMERIC);
fecha_array.sortOn("label");
//
contacto_array.unshift({label:"---Seleccione paciente---", data:"vacio"});
genero_array.unshift({label:"---Seleccione un género---", data:"vacio"});
edad_array.unshift({label:"---Seleccione por edad---", data:"vacio"});
fecha_array.unshift({label:"---Seleccione por fecha---", data:"vacio"});
//
var contacto_dp:DataProvider = new DataProvider(contacto_array);
var genero_dp:DataProvider = new DataProvider(genero_array);
var edad_dp:DataProvider = new DataProvider(edad_array);
var fecha_dp:DataProvider = new DataProvider(fecha_array);
//
contacto_cb.enabled = true;
todos_cb.enabled = true;
genero_cb.enabled = true;
edad_cb.enabled = true;
fecha_cb.enabled = true;
//
contacto_cb.dataProvider = contacto_dp;
genero_cb.dataProvider = genero_dp;
edad_cb.dataProvider = edad_dp;
fecha_cb.dataProvider = fecha_dp;
}

Más información en http://www.pacoarce.com

Manejar la cámara de video con Adobe-AIR

Una tarea que podemos manejar con facilidad en Adobe-AIR y actionscript 3.0,  es abrir la cámara de video de la computadora (o la cámara conectada a la computador). Primero necesitamos importar las clases:

import flash.media.Microphone;
import flash.media.Camera;
import flash.media.Video;
import flash.display.Bitmap;
import flash.display.BitmapData;

Luego iniciar los objetos necesarios:

//Video
//
var mic:Microphone;
var cam:Camera;
var vid:Video;
var bmp:Bitmap;
//

Inicia los objetos:

mic = Microphone.getMicrophone();
cam = Camera.getCamera();
if(cam == null){
win.tomarFoto_btn.alpha = .5
win.tomarFoto_btn.enabled = false;
} else {
vid = new Video(150, 200);
vid.x = 0;
vid.y = 0;
vid.attachCamera(cam);
win.camara_mc.addChild(vid);
}

Y tendrás un recuadro con el video de tu cámara en el escenario.

Hacer menús del sistema con Adobe AIR

Las clases de “menú nativo” permiten acceder a las funciones del menú nativo del sistema operativo donde se ejecuta la aplicación.

Se pueden utilizar los objetos NativeMenu para:

• menús de aplicación (disponibles en Mac OS X),
• menús de ventana (disponibles en Windows y Linux),
• menús contextuales y
• menús emergentes. 

Aqui un ejemplo genérico de cómo hacer menús básicos en Windows y Mac:

package {
    import flash.display.NativeMenu;
    import flash.display.NativeMenuItem;
    import flash.display.NativeWindow;
    import flash.desktop.NativeApplication;
    import flash.display.Sprite;

    public class Menu01 extends Sprite {

        public function Menu01():void {
            var fileMenu:NativeMenuItem;
            var editMenu:NativeMenuItem;
           
            //Es Windows
            if (NativeWindow.supportsMenu) {
                stage.nativeWindow.menu = new NativeMenu();
                fileMenu=stage.nativeWindow.menu.addItem(new NativeMenuItem("Archivo"));
                editMenu=stage.nativeWindow.menu.addItem(new NativeMenuItem("Edición"));
            }
            //Es MAC
            if (NativeApplication.supportsMenu) {
                var mm:NativeMenu = new NativeMenu();
                NativeApplication.nativeApplication.menu = mm;
                fileMenu = NativeApplication.nativeApplication.menu.addItem(new NativeMenuItem("xxxxxxx"));
                editMenu = NativeApplication.nativeApplication.menu.addItem(new NativeMenuItem("ccccccc"));
            }
        }
    }
}