Crear una función constructora en PHP programación orientada a objetos

Instalar el Framework Zend de PHP en una Mac con MAMP

El Framework de desarrollo para PHP, Zend, tiene más de 10 millones de descargas, lo cual lo hace la herramienta más difundida y potente para este lenguaje para desarrollar bajo el esquema MVC.

1. Entrar a zend.com
2. Registrarse en la página
3. Bajar el framework ver 1 o 2 en zip o tar
4. Desempaquetar y guardar el directorio en "htdocs"
5. Generalmente se renombra el directorio a un nombre más sencillo (zf)
5. Abrir el php.ini
6. Buscar el init_path
7. Aumentar la ruta hacia la librería de zf /Application/MAMP/htdocs/zf/libray/
8. Abrir la terminal de Mac /Application/utilities/terminal
9, Crear una "alias": alias zf=/Application/MAMP/htdocs/zf/bin/zf.sh
10. Probar el alias con: zf show version
11. Apaga los servicios de MAMP y vuelves a encender para que se tomen los cambios

Crear un proyecto en Zend

1. Entrar a la terminal de Mac
2. Cambiarse al directorio htdocs cd /Applications/MAMP/htdocs
3. Utiliza el alias creado en la sección anterior: zf create project miAplicacion
4. Verificar las nuevas parapetas en htdocs/miAplicacion
5. Carpetas:
applications
docs
library
public
test
6. Probar la aplicación en un navegador con localhost:8888/miAplicacion/public
7. No deberá aparecer ninguna pantalla de error.


Crear una conexión con mysql-workbench

1. Debe bajar el myslq-workbench de mysql.com. La liga puede cambiar frecuentemente: http://dev.mysql.com/downloads/tools/workbench/
2. Instalarlo en la computador (quizás haga falta bajar la utilería adicional)
3. Abrirlo y debe hacer ya la conexión a MAMP

4. Pulse sobre el recuadro "local instance 8889" y voila!!! ya tendrá el editor

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

Acentos en HTML5

Los acentos en HTML5, y en HTML en general se manejan con el atributo charset. Lo podemos definir como UTF-8 o ISO-8859-1.

Si no se tiene la etiqueta <meta>, podemos escribir los siguientes símbolos en sustitución:

á -> &aacute;
é -> &eacute;
í -> &iacute;
ó -> &oacute;
ú -> &uacute;
ñ -> &ntilde;

Algunos editores trabajan con UTF-8 y si abrimos un documento en ISO-8859-1, nos pueden traer caracteres "extraños", como cuando se trabaja en Windows y lo abrimos en una MAC.

Para XHTML podemos usar:

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />o
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />

Para HTML5 esta etiqueta es más sencilla:

<meta charset="UTF-8">

También debemos de verificar si nuestro servidor no tiene algún charset diferente invado, el cual tenga conflicto con neutra etiqueta <meta>.

Por lo general, en Linux el chaset se encuentra en:

/etc/apache2/conf.d/charsettambién puede cambiarse en el archivo httpd.conf

Si tienes problemas con PHP, puedes añadir un encabezado a cada página como el siguiente:

<?php
header('Content-Type: text/html; charset=UTF-8'); ?>

http://www.pacoarce.com

¿only screen o sólo screen en los media querys, en CSS3?

En muchos estilos en cascada con el media query tienen palabra "only". Si la quitas la palabra "only" funciona igual (aparentemente). Según la W3C, el organismo que regula la internet:

"The keyword ‘only’ can also be used to hide style sheets from older user agents. User agents must process media queries starting with ‘only’ as if the ‘only’ keyword was not present."

Es decir, en un navegador moderno, el only funciona igual con y sin la palabra, pero en agentes antiguos, evita que esa regla u hoja de estilo sea leída. La página de la cita es:

http://www.w3.org/TR/css3-mediaqueries/#media0

http://www.pacoarce.com

Cambio del uso horario en PHP

Si tu servidor tiene diferente huso-horario, lo puedes cambiar desde PHP con la siguiente sentencia, con la cual todas las funciones de fecha y hora quedarán relacionadas con el huso horario:

<?php

date_default_timezone_set("Mexico/General");

echo "La hora en la Ciudad de México es: " . date ("H:i",time()) . "<br />";

?>

También se puede modificar el huso horario desde el archivo INI con el parámetro date.timezone.

Por omisión se tiene la zona UTC o Europe/Lisbon.

El listado de zonas horarias que se pueden utilizar lo puedes encontrar en:

http://www.php.net/manual/es/timezones.php

Para obtener la zona horaria definida, se puede usar la función date_default_timezone_get().

La función localtime() regresa el valor de la fecha y hora local en el servidor dentro de un arreglo:

<?php

date_default_timezone_set("Mexico/General");

$localtime = localtime();

$localtime_assoc = localtime(time(), true);

print_r($localtime);

print_r($localtime_assoc);

?>

Como PHP se ejecuta en el servidor y llega al cliente ya como HTML, para obtener la hora y fecha de la computadora necesitamos utilizar JavaScript.

http://www.pacoarce.com

Introducción a MySQL

Un videito, a ver cómo funciona en el blog. Saludos

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
         

Guardar componentes de Coldfusion en espacios persistentes

• Cuando creamos componentes con la etiqueta <cfobject> o con createObject(),
podemos almacenar la instancia en:
■ En una zona de almacenamiento local (local scopes)
■ En una zona de almacenamiento pesistente (persistent scopes) como podría ser:
– Request
– Session
– Application

Nota: Cuando almacenamos un componente en una zona persistente, su código también queda almacenado en esa zona, por los que cuando cambiamos el código del mismo, éste no se refresca en forma automática.

Crear instancias en espacios persistentes

• Crear una instancia directamente en los espacios persistentes:

■ <cfset application.cfcAnimal = createObject("component","components.animal")
■ <cfobject component="components.animal" name="application.myAnimal">

• Primero crear la instancia y luego subirla al espacio persistente:

■ <cfset myAnimal = createObject("component", "components.animal")>
■ <cfset application.myAnimal = myAnimal>

Acceder a los componentes en zonas o espacios persistentes

•Al igual que otros componentes, podemos acceder a sus métodos y propiedades por medio del espacio persistente (cached scope):

<cfset application.myAnimal =createObject("component", "components.animal")>
<cfset application.myAnimal.name = “Value”>
<cfset myResult = application.myAnimal.MyMethod()>

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

Los métodos getter y setter en Coldfusion 10

Uno de los principios fundamentales en la programación orientada a objetos es que el usuario sólo debe de interactuar con las propiedades del componente o clase por medio de funciones getter y setter, nunca en forma directa.

Adicionalmente, por medio de los métodos getter y setter podremos hacer validaciones de los valores recibidos o modificados:

<cfcomponent>

<cfset variables.myNumericValue = 0>

<cffunction name="getMyNumericValue" access="public" output="false" returnType="numeric">
<cfreturn variables.myNumericValue>
</cffunction>

<cffunction name="setMyNumericValue" access="public" output="false" returnType="void">
<cfargument name="myValue" type="numeric" required="true" >
<cfset variables.myNumericValue = myValue>
</cffunction>

<cfcomponent>

Uso de una propiedad en un componente <cfproperty>

• Las propiedades añadidas con <cfproperty> son vistas desde la documentación.
• La etiqueta <cfproperty> contiene algunos atributos que aydan en la definición de la propiedad
• La etiqueta <cfproperty> genera automáticamente, por medio de el atributo accesors,  los métodos getter y setter

Atributos de la etiqueta <cfproperty>

• name: nombre de la propiedad
• default: valor por omisión de la propiedad
• displayName: nombre descriptivo de la propiedad
• required: define si la propiedad es requerida
• serializable:determina si la propiedad es serializable
• type: tipo de dato de la propiedad

El atributo Accessors

• <cfcomponent> sólo generan los getters y setters en forma automática cuando de tiene el atributo accesors = "true".

Ejemplo:

<cfcomponent accessors=”true”>

<cfproperty name="dsn" displayName="dataSource" hint="Data source to be used in this component" type="string" />

<cfset variables.myNumericValue = 0>

<cffunction name="GetMyNumericValue" access="public"returnType="numeric">
<cfreturn variables.myNumericValue>
</cffunction>

<cffunction name="SetMyNumericValue" access="public" returnType="void">
<cfargument name="myValue" type="numeric" required="true" >
<cfset variables.myNumericValue = myValue>
</cffunction>

</cfcomponent>

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

Breve historia de MySQL

MySQL fue desarrollado en 1996 por una empresa sueca llamada TCX. Es una base de datos relacional de código abierto que se encuentra estrechamente relacionada con productos como PHP, Apache y Linux, que también son de código abierto.

MySql es un sistema administrador de bases de datos relacionales que permite el manejo, acceso y almacenamiento seguro y rápido de información, especializado en Internet (sistemas cliente-servidor). Usted puede bajar la base de datos en forma gratuita de la página http://www.mysql.org. Recomendamos ampliamente la instalación de la paquetería gratuita de Easyphp.org, que instala en un mismo paquete el sistema operativo web Apache y PHP con MySQL.

Antes de abordar el manejo de MySQL definiremos términos bases.

Términos básicos: Tabla, campo y registro

Una TABLA es un conjunto de información que tierre relación entre sí. Una BASE DE DATOS es el conjunto de tablas que describen una entidad de información mayor. Las tablas pueden tener relación entre ellas y ser complementarias.

Las tablas están formadas por REGISTROS o RENGLONES. Estos son la unidad básica que describe a un objeto o a una transacción, por ejemplo, los datos de un artículo de venta, la información de una persona para enviarle un correro, etc. A su vez el REGISTRO está formado por CAMPOS o COLUMNAS, que son la unidad básica de información, y son una propiedad específica de un objeto o transacción, por ejemplo, la fecha de compra, el número de ISBN de un libro o el correo electrónico de una persona.

Dependiendo de la COLUMNA, esta tendrá un TIPO DE DATO específico, que indicará la forma de almacenar, las caracterísitcas y limitantesdel CAMPO.

Diseño de una base de datos

Para diseñar una base de datos podemos seguir los siguentes pasos:

1. Cada tabla deberá tener un nombre único y específico.

2. Cada una de las tablas deberá tener al menos un campo

 

3. Cada tabla puede tener cero o más filas. estas pueden estar desordenadas.

4. Cada valor en una COLUMNA tendrá el mismo tipo de dato.

5. A su vez, el campo o conjunto de campos único (que no se repite su valor entre los diferentes REGISTROS) con el cual se accesa la información de las tablas, y cuyo valor identifica unívocamente al REGISTRO se le conoce como LLAVE PRIMARIA.

6. Solo existirá una llave primaria por tabla.

7. Una LLAVE SECUNDARIA (externa o foránea) es un campo o conjunto de campos, que es una LLAVE PRIMARIA en otra tabla.

8. La relación entre LLAVES PRIMARIAS - LLAVES FORANEAS crea una relación de padre-hijo entre las TABLAS de una base de datos.

Por ejemplo:

Supongamos que tenemos un sistema escolar. Tendremos una tabla con los datos del alumno (llamada ALUMNOS), y en ella almacenaremos una llave para el número de salón. Esta será una LLAVE SECUNDARIA.

En otra tabla (la llamaremos SALONES) almacenaremos los datos de los salones, como su ubicación en el edificio, su número de asientos y su equipamiento (pizarrones, proyectores, mapas, etc). La LLAVE PRIMARIA de esta tabla es la LLAVE SECUNDARIA de la tabla ALUMOS, por lo que se tiene una relación de PADRE (Tabla ALUMNOS) e hijo (tabla SALONES).

Antes de pasar a la creación de tablas y bases de datos, estudiaremos el elemento básico, que son los tipos de datos y los tipos de columnas para formar las tablas.

 

Crear procesos automáticos para MySQL

Estado del administrador de tareas programadas Editar sección
Lista de tareas:

SHOW PROCESSLIST\G
Valor de la variable event_scheduler:

SHOW VARIABLES LIKE 'event_scheduler';
Activación del administrador:

SET GLOBAL event_scheduler = ON;

Hacer un respaldo automático en Windows

Podemos utilizar el programa mysqldump como se muestra:

set FECHA=%date%
set FECHA=%FECHA:/=%
set FECHA=%FECHA: =%
set FECHA=%FECHA::=%
set FECHA=%FECHA:,=%
set FILE=C:\\Backups\\Backup_%FECHA%.sql
C:/mysql/bin/mysqldump.exe -h localServer -u USER -p PASWWORD -r %FILE% DBNAME

Y lo programas en la tarea en Windows

Hacer un respaldo con la herramienta mysqldump

mysqldump ---user admin ---password=password mydatabase > sql.dump

http://www.pacoarce.com

Añadir métodos a los componentes en Coldfusion 10

Añadir métodos a los componentes en Coldfusion 10

Los métodos son definidos dentro de los componentes:
Para definir los métodos, utilizamos uno de los siguientes modificadores de acceso:

■ private: disponible sólo en el componente donde es declarado  el método. También es válido en las clases extendidas de la clase original.
■ package: disponible en la clase donde se define el método, en las clases extendidas y en otras clases del paquete. Un paquete son otras clases definidas dentro del folder de la aplicación.
■ public: disponible para todas las clases de la aplicación.
■ remote: disponibles en forma local o remota por medio de una URL, Flash o web server.

Los métodos de las instancias

Funcionan igual  que las funciones definidas por el usuario.
Generalmente trabajan con los datos de la misma instancia.
Interactúan con otros métofos de la instancia


<cfset variables.birthDate = CreateDate(1975,6,9)>
<cffunction name="CalculateAge" access="public" returnType="numeric" >
<cfreturn DateDiff("yyyy", variables.birthDate, Now())>
</cffunction>

Llamar a un método

<cfset myInstance = createObject("component","components.animal")>
<cfoutput>
   Age : #myInstance.CalculateAge()#
</cfoutput>

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

Joomla tiene cuatro extensiones:

1. Modulos
2. Componentes
3. Plugins
4. Plantillas

Los módulos son las extensiones más sencillas en Joomla, Son pedazos de código que podemos colocar en cualquier parte y en cualquier número. Los siguientes datos es parte de lo que investigué en la página de joomla.org/Developpers:

Estructura de archivos

Iniciaremos, aunque usted no lo crea, con el "hola mundo". Hay cuatro archivos básicos que se utilizan dentro del patrón estándar en el desarrollo de un módulo:

• mod_helloworld.php - Este archivo es el principal punto de entrada para el módulo. Se llevarán a cabo las rutinas de inicialización necesarias, llamar a las rutinas auxiliares para recoger todos los datos necesarios, e incluir la plantilla que muestra la salida del módulo.
• mod_helloworld.xml - Este archivo contiene información acerca del módulo. En él se definen los archivos que necesitan ser instalados por el instalador de Joomla! y especifica los parámetros de configuración del módulo.
• helper.php - Este archivo contiene la clase helper que se utiliza para hacer el trabajo real en la recuperación de la información que se muestra en el módulo (por lo general a partir de la base de datos o alguna otra fuente).
• tmpl / default.php - Esta es la plantilla del módulo. Este archivo tomará los datos recogidos por el mod_author_related.php y generará el código HTML que se muestra en la página.

Con esta estructura de archivos, se está siguiendo un esquema MVC, donde la "Vista" es el archivo default.php y las reglas de negocio se encuentran en helper.php.

Faltan otros dos archivos, como veremos más adelante, que servirán para preveer que alguien ejecute directamente muestro módulo entrando a su directorio o carpeta.

1) Creación del mod_helloworld.php

Primero crea una carpeta para almacenar tu super módulo. Por tradición milenario se llamaría como se llama tu módulo, en este caso mod_helloworld y ahi vas escribiendo y almacenandotus archivos.

El archivo mod_helloworld.php llevará a cabo tres tareas:

• Incluir el archivo helper.php que contiene la clase que se utiliza para recoger los datos necesarios.
• Invocar el método apropiado para recuperar los datos.
• Incluir la plantilla para mostrar la salida.

 Aqui ek primer despiste; helper a mi me sonaba como archivos para desplegar la ayuda, pero son las rutinas auxiliares. Punto muy importante, se utiliza PHP orientado a objetos.

Siguiendo estos tres puntos, vamos a colocar un poco de código en nuestro archivo.
La clase helper está definida en nuestro archivo helper.php .
Este archivo se incluye con la declaración require_once .

require_once dirname(__FILE__).'/helper.php';

require_once se utiliza porque nuestras funciones auxiliares se definen dentro de una clase, y sólo queremos la clase definida, una vez.

Para invocar a nuestro método utilizaremos la siguiente líneas:

$hello = modHelloWorldHelper::getHello( $params );

Recuerde que es programación ortinetada a objetos. Estamos definiendo una método que se llama getHello() y estamos pasando un parámetro. El primer archivo completo quedaría así:

<?php
// no direct access
defined( '_JEXEC' ) or die( 'Restricted access' );
 
// Include the syndicate functions only once
require_once( dirname(__FILE__).DS.'helper.php' );
 
$hello = modHelloWorldHelper::getHello( $params );
require( JModuleHelper::getLayoutPath( 'mod_helloworld' ) );
?> 

La clase modHelloWorldHelper se crea dentro del archivo helper.php, como se ve a continuación

2) Creación del helper.php

El archivo helper.php contiene la clase necesaria para recuperar los datos que se muestran en la salida del módulo. Esta clase a su vez tendrá un método que se encargara de dicha tarea.

Aquí está el código para el archivo helper.php:

<?php
class modHelloWorldHelper
{
    
    public static function getHello( $params )
    {
        return 'Hello, World!';
    }
}
?>

En el ejemplo estamos leyendo un parámetro que no utilizamos, pero es para preveer su uso, aunque obviamente aqui no es necesario. Creamos la clase modHelloWorldHelper (que no hay ninguna regla que te obligue escribir con esa sintaxis el nombre de la clase, pero ya es un clásico en la comunidad de joomleros) y luego el método getHello, donde puedes vaciar todos tus conocimientos sobre la herramienta e impresionar a tus cuates.

3) Creación del tmpl/default.php

El archivo default.php es la plantilla que muestra la salida del módulo. El código para el archivo default.php es el siguiente:

<?php // no direct access
defined( '_JEXEC' ) or die( 'Restricted access' ); ?>
<?php echo $hello; ?>

 O sea, que hay que hacer una carpeta que se llame tmpl y ahi guardar el archivo. Ojo.

4) Creación del mod_helloworld.xml

El mod_helloworld.xml se utiliza para especificar los archivos que el instalador tiene que copiar, y sean usados por el gestor de módulos para determinar qué parámetros se utilizan para configurar el módulo. Otras informaciones sobre el módulo también se especifica en este archivo.
El código para mod_helloworld.xml es el siguiente:

<?xml version="1.0" encoding="utf-8"?>
<extension type="module" version="2.5.0" client="site" method="upgrade">
    <name>Hello, World!</name>
    <author>John Doe</author>
    <version>1.0.0</version>
    <description>A simple Hello, World! module.</description>
    <files>
        <filename>mod_helloworld.xml</filename>
        <filename module="mod_helloworld">mod_helloworld.php</filename>
        <filename>index.html</filename>
        <filename>helper.php</filename>
        <filename>tmpl/default.php</filename>
        <filename>tmpl/index.html</filename>
    </files>
    <config>
    </config>
</extension>

Si ha manejado otras aplicaciones, como el SCORM, verá que es muy similar al "manifiesto".

Y si observa, aparecen dos archivos invitados nuevos: index.html y tmpl/index.html. Ambos son para preveer a los aprendices de hacker entrar a nuestra carpeta. Este archivo puede ser tan sencillo como:

<html><body bgcolor="#FFFFFF"></body></html>

Con esto hemos completado nuestro directorio del módulo, el cual deberá tener los siguientes archivos:

• mod_author_related.php
• mod_author_related.xml
• helper.php
• tmpl / default.php

Opcionalmente puede añadir los archivos

• index.html
• tmpl / index.html

Si no va a utilizar los archivos html, no olvide también quitarlos del manifiesto.

Empaquete en un formato zip todos los archivos (no el directorio, sino solo los archivos y la carpeta tmpl).
Intégrelos a Joomla por medio de Extensiones
Colóquelo dentro de la página con  Extensiones > Administrador de módulos

Asi tendremos un módulo muy sencillo en Joomla! y lo mejor de todo es que si funciona. El presente blog fue tomado delmanual de desarrolladores.

Los archivos los encuentras aqui.


http://www.pacoarce.com

ActionScript: Línea que se estira (AS 3.0)

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


Algunas veces queremos tener una línea que se estire de ambos extremos. Eso nos podría servir para juegos, diagramas, etc. El siguiente código genera una linea, creada desde el archivo SWF, de una linea. Se le indica la ubicación, la longitud y el color:

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

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

      public function Linea(xx,yy,lon,color):void {
         //Sujetador
         this.color = color;
         this.x1 = xx;
         this.y1 = yy;
         this.x2 = xx + lon;
         this.y2 = yy;
         //
         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.addEventListener(TimerEvent.TIMER, onMueve);
         tiempo.start();
         //trace("inicio",e.target.name,e.target.x, e.target.y);
     }

    function onMueveCuadro2(e:MouseEvent):void {
         tiempo.stop();
         e.target.stopDrag();
         pintaLinea();
     }

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

     function pintaLinea () {
         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(2, 0);
     }
   }
}

http://www.pacoarce.com

Conectar a un módulo de Joomla 2.5 con la base de datos interna

Por lo general, las cosas divertidas empiezan cuando nos conectamos a las bases de datos. En Joomla tenemos una base de datos interna dentro de la instalación del paquete, que puede ser MySQL y en la versión 3.0 pueden sel otras, incluso SQLite.

También podemos conectar con una base de datos externa, por ejemplo, una base de datos de clientes, facturación, libros, lo que sea. En este blog, que se basa en la documentación de Joomla! Developers, trataré de poner las cosas en claro (al menos para mi) de cómo conectarnos con la base de datos interna, crear una tabla, leerla, etcétera.

Para ello tenemos que utilizar la clase JDatabase, que nos simplifica mucho el uso de la base de datos. Recuerde que se está utilizando PHP orientado a objetos, de locual es deseable que tenga conocimientos.

También necesita tener conocimientos de cómo hacer un módulo en Joomla 2.5.

Crear una tabla desde el instalador del módulo

Desde e proceso de intslación de nuestro módulo, podemos crear una tabla y todo el código para manipularla. Incluso se puede hacer para diferentes tipos de bases de datos, no sólo para MySQL.

Este código se anexa desde el "manifiesto" de nuestro módulo, es decir, el archivo XML. En nuestro ejemplo anterior, de donde puede bajar los archivos, puede definir estos procesos con el siguiente código:

<install>
     <sql>
         <file driver="mysql" charset="utf8">sql/mysql/install.mysql.utf8.sql</file>
     </sql>
</install>
 
<uninstall>
     <sql>
         <file driver="mysql" charset="utf8">sql/mysql/uninstall.mysql.utf8.sql</file>
     </sql>
</uninstall>
 
<update> 
    <schemas>
        <schemapath type="mysql">sql/mysql/updates</schemapath>
    </schemas> 
</update>

Necesita crear, dentro de la carpeta de su módulo, las subcarpetas sql y otra para mysql, para crear los archivos para otras bases de datos. Ahi guardará los archivos  install.mysql.utf8.sql, que no es otra cosa que archivos de texto con las instrucciones correspondientes para cada base de datos, que por lo general estarán en SQL.

El archivo install.mysql.utf8.sql se muestra a continuación, y si sabe MySQL observará que es código propio de esta base de datos:

CREATE TABLE IF NOT EXISTS '#__helloworld' (
        `id` int(10) NOT NULL AUTO_INCREMENT,
        `hello` text NOT NULL,
        `lang` varchar(25) NOT NULL,
 
  PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8 AUTO_INCREMENT=1;
 
INSERT INTO '#__helloworld' ('hello', 'lang') VALUES ('Hello World', 'en-GB');
INSERT INTO '#__helloworld' ('hello', 'lang') VALUES ('Hola Mundo', 'es-ES');
INSERT INTO '#__helloworld' ('hello', 'lang''') VALUES ('Bonjour tout le monde', 'fr-FR');

Este listado, tomado del ejemplo del manual, crea la tabla y unos cuantos elementos. Aún no hemos utilizado estas instrucciones.

El siguiente archivo utilizamos la peligrosa sentencia drop-table en el archivo

uninstall.mysql.utf8.sql:

DROP TABLE IF EXISTS '#__helloworld'

El siguiente archivo no es un UPDATE de un registro, sino más bien la actualizacion de la base de datos y de momento solo tiene un comentario:

# Placeholder file for database changes for version 1.0.0

Cómo utilizar las sentencias de la base de datos

Una vez que ya tenemos nuestras definiciones y archivos para crear y desinstalar la tabla en la base de datos interna de Joomla!, procederemos a llamar a los archivos. Recuerde que la lógica del módulo la encontraremos en el archivo helper.php. 

Necesitamos conectarnos a la base de datos y crear la tabla

http://www.pacoarce.com