Archivo

Archivo para la categoría ‘Fácil’

Primeras experiencias con RADPHP

miércoles, 11 de julio de 2012 14 comentarios

   28e58a2b951637c93dfd69d9e6031a11Llevaba tiempo con ganas de probar en entorno de Embarcadero para PHP y al final estos días he podido dedicarle algo de tiempo; Al menos e podido instalarlo, que ya es mucho y hacer unos primeros ejemplos…   ;-)

   Para los que estáis como yo en estos temas (bastante verdes) os iré comentando mis primeras impresiones y los problemas con los que me he ido encontrando.

   La primera impresión una vez instalado el entorno ha sido muy gratificante, simplemente por la imagen de ver los menús en castellano. Ya se que no es algo “importante” a nivel técnico, sobre todo para los que llevamos tiempo programando en los IDE’s de Dephi, pero sí es gratificante a nivel visual.Imagen1251     Junto con la instalación de RADPHP (en mi caso ha sido un paso previo, porque ya lo tenía), he instalado WAMPServer, que instala las últimas versiones de Apache, MySQL y PHP, además de un pequeño programita para gestionar los servicios, que a mi me es de gran utilidad. Hay otros programas similares que realizan la misma instalación, como por ejemplo XAMPP.

   Aparte del detalle de los menús, la primera impresión es que el entorno es conocido y eso tranquiliza y agiliza mucho los primeros pasos. Proyectos, opciones generales, ventanas de depuración, diferentes opciones de visualización y personalización,… todo está, donde uno espera que esté, al menos para los que ya estamos acostumbrados a este entorno.

Una vez que todo parece que está correcto, lo primero que un buen programador hace es generar su primer programa.
Imagen1256¿Cual? Seguramente el programa por antonomasia y generado en el mayor número de lenguajes: “El programa Hola mundo!”.

Generamos una aplicación PHP desde el menú de Archivo, y cuando nos aparece el diseño de la UNIT1, colocamos un botón (TButton) y una etiqueta (TLabel).

En el evento OnClick del botón programamos lo siguiente:

function Button1Click($sender, $params)
    {
      $this->Label1->Caption = 'Hola Mundo';
    }

Al ejecutar se nos abre el navegador con el botón y el Label y con un funcionamiento “normal” para lo programado. Nuestro primer programa ha sido todo un éxito.   ;-D

<DESCARGA DEL CÓDIGO FUENTE>

 

Conectar a Base de Datos.

El siguiente ejemplo que he probado es una conexión a Base de Datos. Para ello, RADPHP en la carpeta de Demos trae un Script de SQL con el que generar una Base de Datos de pruebas llamada osCommerce. Corremos el script en el servidor de MySQL y tenemos la Base de Datos creada al instante.

Antes de continuar debemos descomentar la siguiente línea en el fichero de configuración php.ini.template, si no lo está:

  • extension=php_mysql.dll 

    Si vamos a trabajar con otros SGBD’s debemos buscar las líneas similares y descomentarlas. Por ejemplo, en mi caso, para Microsoft SQL Server,  hay que hacerlo con la línea:

  • extension=php_mssql.dll

En el caso de SQL Server, podéis leer más detalles en esta página de la documentación online, junto con otras opciones de configuración y posibles problemas que pueden surgir. Es de suponer que con el resto de Bases de Datos funcione de la misma manera y siguiendo pasos similares para la configuración.

Para el ejemplo he colocado componentes de forma similar a como se haría en un formulario estándar de Delphi. Un TDatabase, un TTable y un TDatasource. Con el mismo sistema de conexión (propiedades). Por último un DbGrid para visualizar la tabla de Productos.Imagen1264

Basta con activar la tabla para comprobar que obtenemos los resultados esperados.

 function Button1Click($sender, $params)
    {
      // Cambiar el estado  abierto/cerrado
      $this-&gt;tblProductos-&gt;Active = ! ($this-&gt;tblProductos-&gt;Active);
    }

 

Imagen1265

<DESCARGA DEL CÓDIGO FUENTE>

 

Uso de Templates

Por último (al menos para esta entrada) me he puesto a probar los Templates.

Podemos integrar un formulario (componentes) generado en RADPHP con una plantilla HTML utilizando “Smarty Templates Engine”, que permite utilizar TAG’s en el HTML, que posteriormente se combinan con el formulario y los componentes diseñados con las plantillas. En la ayuda en línea de RADPHP podemos encontrar la explicación del procedimiento para realizarlo.

Primero diseñamos un formulario básico para realizar un Login. Algunos labels, un par de componentes de edición para el usuario y el password, un botón para el código de comprobación y poco más.

Imagen1259

El código básicamente comprueba que el usuario y contraseña sean los definidos como admin/1234 y visualiza una de las dos imágenes que hay a a derecha.

Si lo ejecutamos en el navegador podremos ver lo siguiente (como era de esperar):

Imagen1260

Lo siguiente que tenemos que hacer es diseñar un “template”; La plantilla que utilizaremos para visualizar lo que hemos diseñado. Para ellos Tenemos que definir un fichero HTML/CSS como lo haríamos normalmente; Una vez diseñado añadimos los siguientes TAG’s para que el «Engine» de Smarty pueda realizar su trabajo:

  • {%$HeaderCode%}:  En la parte de la cabecera.
  • {%$StartForm%}{%$EndForm%}: En la parte del BODY encerrando la sección donde aparecerán los componentes.
  • {%$Nombre_Componente%}: Para cada uno de los componentes que aparezcan en la plantilla.

Importante la nomenclatura; En algún ejemplo que hay en EDN está incorrecto y yo estuve un buen rato hasta que averigüé la correcta. En mi caso he diseñado un HTML/CSS con el siguiente contenido:

Fichero HTML con el Template de smarty  (código fuente) (fichero CSS)

Si vemos la plantilla en el navegador podemos apreciar algunos de los TAG’s que hemos comentado.

Imagen1261

Configuramos en el fichero PHP las propiedades TemplateEngine y TemplateFilename. Con esto es suficiente para poder ejecutar el ejemplo y que el resultado fusione el fichero PHP con nuestra plantilla HTML/CSS. El resultado en el navegador es este:

Imagen1262

Una vez tenemos completado el proyecto y funcionando desde el IDE, lo primero es hacer el Imagen1263“deployment” en el servidor Apache que tengo instalado en local. Para ello el propio IDE de Delphi cuenta con un asistente.  Desde el menú de herramientas lanzamos el “Asistente de despliegue”.

Este asistente nos pide el directorio donde se va a copiar la aplicación; En mi caso, es el directorio c:\wamp\www, y a partir de ahí, el asistente en función de los elementos utilizados en el proyecto, copia todo lo  necesario al directorio para poder ejecutar la aplicación.

Una vez hecho esto, hay que copiar manualmente la plantilla y añadir a la configuración de PHP el directorio donde se encuentran los ficheros. Al fichero PHP.INI, a la variable include_path , le añadimos el path del directorio rpcl.

En ejemplo se ha ejecutado también correctamente.

Finalmente, he subido el ejemplo al servidor donde tengo el blog, para ver si eran necesarias configuraciones adicionales. Ha bastado con copiar los mismos ficheros a un directorio de mi servidor. Podéis probarla desde aquí.

Enlaces:

Hasta aquí esta primera entrada referente a RADPHP. La impresión general ha sido muy buena.He obtenido algunos errores en el entorno (aunque hay que decir que mi máquina de pruebas está ya muy «trasteada» y no descarto que eso tenga algo que ver), y también he echado en falta documentación (tanto desde el IDE, como fuera de él), pero la impresión final ha sido buena.
Pensé que para alguien como yo, con conocimientos reducidos en este apartado, el primer contacto sería mucho más «duro».  ;-D

Espero poder seguir avanzando es este tema.

Un saludo y hasta la próxima.

Categories: Fácil, RADPHP Tags: ,

Testeando XE2… (FireMonkey)

martes, 13 de septiembre de 2011 11 comentarios

Pues ya tengo Delphi XE2 en marcha. Que ya lo tengo instalado ¡Vamos!

No se a vosotros, pero a mi me pasa (y no sólo con esta versión) que una vez que la tengo instalada, lo primero que se me ocurre es probarla. Probar las nuevas características y ver qué tal funcionan.

¡¡Eso es lo que hace todo el mundo!! Diréis.

Bueno, sí y no. Me refiero a «probarlas en frío». Sin saber nada más. Sin leer nada más.
Se trata de abrir un proyecto en blanco y empezar a probar cosas. Cosas totalmente nuevas. Cosas que no existían hasta ahora. Cosas de las que he oído hablar, pero no he leído nada.

Eso me da una idea de cómo son de fáciles a la hora de asimilar. Difíciles, complicadas, rebuscadas,… Busco documentación y veo cómo se llega a ella, si la hay, cómo es de clara,…

Todo el mundo habla estos días de FireMonkey.  ;-D    ¡¡Pues allá que voy yo!!

He ido al menú de fichero y he creado una nueva aplicación de este tipo (Fire Monkey HD Application).

A priori todo parece normal; el formulario se ve algo diferente, pero todo lo demás tiene «la misma pinta».

Pongo algunos componentes, unos botones, un checkbox, una statusBar y una imagen. Mi primera sorpresa viene cuando voy a buscar la propiedad Caption del botón y no está.   8-|

¡No puede ser! Vuelvo a buscar y efectívamente no está.

En su lugar veo la propiedad Text. Pruebo y efectívamente pertenece al caption del TButton.

No parece que tenga mayor importancia…

Pongo un checkbox y al ir a buscar la propiedad Checked…  ¿??¿?¿   ¡¡No está!!    8-||

Vuelvo a revisar las propiedades y…  encuentro una propiedad IsChecked que pertenece a lo que normalmente se hace con la propiedad Checked.

Dejando de lado esto (cuestión de la adaptación de los nuevos componentes adquiridos por Embarcadero-me imagino-) el resto de cosas que he probado son bastante intuitivas y algunas bastante impresionantes. Aplicar un efecto (para lo que antes necesitábamos bastante código o componentes especializados) o realizar una rotación de una imagen es algo «trivial» (por su sencillez).

La velocidad es muy buena y la primera impresión muy positiva.

Os dejo este primer ejemplo; Bastante «tonto» por su funcionalidad, pero también por la complejidad que me ha conllevado (bastante poca).

Aquí los fuentes y el ejecutable, aunque sinceramente no creo que tengan mucho interés, desde en punto de vista de la codificación.

NOTA: Sigo buscando cómo asignarle un texto a la StatusBar que he puesto en el formulario…    ;-D

Un saludo.

Crear componentes en un TScrollBox (runtime)

martes, 26 de octubre de 2010 5 comentarios

Se trata de un ejemplo sencillo que puede servir a quien esté comenzando con la creación de componentes en runtime y asignación de eventos. En este caso se trata de un visualizador de imágenes, que crea componentes TImage dentro de un TScrollBox, a modo de miniaturas, para luego visualizar esas imágenes en un control TImage a tamaño mayor.


Se utiliza también una TObjectList para almacenbar los objetos (componentes TImage y TPanel) que se van creando en ejecución para posteriormente poder acceder a ellos. Para crear los componentes se utiliza un código com este:

var
  im:TImage;
  i:Integer;
  pnl:TPanel;
begin
 
  // Para cada imagen
  for i := 0 to (imList.Count - 1) do begin
    // Crear el control imagen
    im := TImage.Create(nil);
    // Asignar propiedades
    im.Parent := ScrollBox1;
    im.Height := ScrollBox1.Height;
    im.Width := im.Height;
    im.Top := 0;
    im.Left := ((im.Width + 15{panel} + 4) * i);
    im.Transparent := true;
    im.Align := alLeft;
    im.Stretch := True;
    im.Proportional := True;
 
    // Cargar
    im.Picture.LoadFromFile(imList[i]);
    // vebto OnClick
    im.OnClick := ClickImage;
    // Añadirla a la lista de objetos
    oList.Add(im);
 
    // Separados
    pnl := TPanel.Create(nil);
    pnl.Parent := ScrollBox1;
    pnl.Left := im.Left + 5;
    pnl.Width := 15;
    pnl.Height := im.Height;
    pnl.Align := alLeft;
    pnl.Color := clBlack;
    // Aadirlo a la lista de objetos
    oList.Add(pnl);
 
  end;

Se puede descargar el código completo del ejemplo desde aquí .
Actualizo el contenido en DropBox.
Este ejemplo ha surgido a partir de este hilo en el ClubDelphi.

Otros ejempos útiles sobre el mismo tema, relacionados con este pueden ser «Crear, mover y redimensionar controles en Runtime (IDE)» o «Crear/destruir comp. en Runtime y moverlas con el ratón«.

Un saludo.

Categories: Delphi, Ejemplos, Fácil Tags: ,

Google Maps en Delphi – II

lunes, 29 de junio de 2009 37 comentarios

En la última entrada acerca de la API de Google Maps, vimos cómo mostrar un Mapa utilizando la API en un programa Delphi, cómo centrarlo en una posición predefinida y utilizando un Zoom predeterminado.

Además como seleccionar entre los diferentes controles que podemos añadir al mapa (Zoom, Vista general, tipo de mapa…).

También cómo colocar una marca en una ubicación y cómo generar una ventana con información asociada a esa marca (NOTA1).

NOTA1: De forma similar se pueden colocar otros elementos sobre el mapa, como:

  • Líneas, polilíneas y polígonos.
  • Marcas con iconos personalizados.
  • Rutas

Una vez visto cómo mostrar el mapa, lo que nos queda es ver cómo podemos, desde nuestro programa Delphi, interactuar con él; Es decir, que el usuario pueda modificar determinadas características del mapa que tiene en pantalla, y nosotros podamos recuperar esos cambios, para utilizarlos en nuestro programa.

Vamos a continuar con el ejemplo visto en las entradas anteriores; Mostraremos al usuario un Mapa ubicado en una determinada posición. El usuario debe poder «reubicar» la vista del mapa y modificar el Zoom con que está visualizando el mapa, y esos son los valores que obtendremos para posteriormente almacenarlos y actualizarlos en nuestro programa.

  • Coordenada de Longitud
  • Coordenada de Latitud
  • Zoom actual del mapa

La forma de conseguirlo, es añadir a la página web el código necesario para capturar eventos que se produzcan en el mapa. Incluiremos controles de edición, donde se almacenan la longitud/latuitud y Zoom, que después recuperaremos desde el programa Delphi.

GEvent.addListener(map, "click", function (overlay,point)
GEvent.addListener(map, "zoomend", function (oldLevel, newLevel)
GEvent.addListener(map, "mousemove", function(latlng)

Aunque uno no esté muy familiarizado con el tema (yo mismo no lo estoy mucho  ;-D ), no hacen falta muchas explicaciones para comprender los eventos; «Capturaremos» en OnClick, OnZoomEnd y OnMouseMove sobre el mapa. Aquí se puede acceder a la lista de eventos, métodos y propiedades de la clase Gmap.

En el caso del evento OnClick, por ejemplo, utilizaremos un código como este:

GEvent.addListener(map, "click", function (overlay,point){
if (point){
document.posicion.x.value=point.x
document.posicion.y.value=point.y
document.posicion.z.value=map.getZoom()
TipoMapa = map.getCurrentMapType().getName()
document.posicion.t.value=TipoMapa
}

Obtenemos información del punto actual (utilizando un parámetro) y el Zoom actual y el tipo de Mapa utilizando métodos de la clase GMap. Todos ellos se almacenan (como hemos comentado antes) en componentes de tipo Text, que nos sirven como «paso intermedio» para luego capturar esos valores de la página Web desde nuestro programa.

Como resultado final, os dejo el ejemplo que se adjunta con esta entrada. En él he incluído/integrado la parte de Geocodificación (visto en las entradas I y II), y el código y modificaciones necesarias para recuperar posición, Zoom y tipo de Mapa (este incluído a última hora) que el usuario selecciona en un Mapa.

Información capturada

La información de los lugares puede ser guardada y recuperada de un fichero de texto; La estructura es bastante simple y no hace falta mayor explicación. Se almacena en el mismo directorio de la aplicación y recibe el nombre de «Lugares.txt».

Recuperar y Guardar ubicaciones

La información que podemos capturar del Mapa (utilizando la clase GMap) y de otros elementos que estén incluíds en el mapa (imágenes, líneas, marcas,…) es muy extensa y está detallada en las referencias de la API de Google Maps.

Personalmente, creo que las posibilidades de ampliación son muy grandes y bastantes más sencillas de lo que a priori puede parecer.

Se puede descargar el ejemplo completo desde aquí.
<DESCARGAR EJEMPLO>

Espero que estas entradas hayan sido de utilidad. Como siempre cualquier comentario, corrección, sugerencia,… es bienvenida. ;-D

Un saludo.

ACTUALIZACIÓN (10 Febrero 2012): Dado el cambio de política de Google, ahora es necesario (obligatorio) colocar la key que se proporciona desde Google para poder utilizar la API. Es necesario modificar el fichero _mapa.txt del recurso y  recompilarlo utilizando RC.CMD.

 

Cargar datos de un TXT a un TDataset (utilizando ADO) – Parte 2

viernes, 22 de mayo de 2009 19 comentarios

Continuando con esta entrada (parte 1), nos queda ver como hacer algo similar, pero con un archivo de texto cuyos datos están separador utilizando algun caracter especial (TAB, coma, punto y coma,…)

Por defecto, para la lectura de un fichero de texto medianto ADO (Jet 4.0) se utiliza la información que hay en el registro de windows, que se considera la configuración por defecto. Esta configuración se encuentra en la clave:
‘\SOFTWARE\Microsoft\Jet\4.0\Engines\Text’

Dentro de HKEY_LOCAL_MACHINE y en el valor Format.

De todas formas, para tener un mayor control sobre el procesos para acceder a los datos del fichero de texto, es recomentable (altamente recomendable diría yo) crear un fichero de esquema.
El fichero de esquema siempre tienen el nombre schema.ini y se encuentra en la misma carperta del origen de datos. En el fichero de esquema se definen:

  • El formato del archivo.
  • El nombre, la longitud y el tipo de cada campo (columnas).
  • El juego de caractreres utilizado en el archivo de datos.
  • Conversiones especiales para los tipos de datos.

Si tuviéramos un archivo similar a este (aunque aquí he utilizado para el ejemplo el separador ‘‘ que no parace muy adecuado):

Sierra eléctrica-1-250
Machete-5-2.70
Detergente-1-10
Delantal-2-7.25
Afilador-3-5
Cortacesped-6-95
Televisor plasma-2-200
Caja clavos-4-12
Ordenador-1-300
Caja lápices-2-11
Paquete folios-1-10

En nuestro archivo schema.ini debemos añadir lo siguiente para conseguir un acceso correcto a los datos:

  • Format=Delimited(-); Para definir nuestro separador de campos
  • ColNameHeader=False;  Puesto que no están definidas dentro del archivo de texto los títulos de las columnas.
  • A continuación nombres y tipos de las columnas.
  • CharacterSet=ANSI; Para definir la codificación del texto.
  • MaxScanRows=0; Define cuantas líneas escanea el motor para determinar el tipo de datos de cada columna. 0 para todas.

Finalmente nuestro archivo de esquema quedará de compleatado de la siguiente manera:

 [Datos.txt]
Format=Delimited(-)
ColNameHeader=False
Col1=Producto char
Col2=Cantidad Integer 
Col3="Precio Total" currency 
MaxScanRows=0
CharacterSet=ANSI

El ejemplo completo para acceder a los datos de un TXT utilizando las opciones del Registro de Windows, se pueden descargar desde aquí.
<Descargar ejemplo>

El ejemplo completo para acceder a los datos de un TXT utilizando las opciones de un archivo de esquema schema.ini, se pueden descargar desde aquí.
<Descargar ejemplo>

Cargar datos de un TXT a un TDataset (utilizando ADO)

viernes, 22 de mayo de 2009 Sin comentarios

Una de las muchas posibilidades que ADO provee para acceder a diferentes tipos de datos es la que podemos utilizar para acceder a datos de un fichero de Texto, siempre que estos estén mínimamente organizados.

Básicamente trabajamos con dos tipos de ficheros de texto:

  • Los que los campos son de ancho fijo y por lo tanto no hace falta separador.
  • Aquellos en los que los datos utilizan un separador de campos. Ya sea «punto y coma», «coma» o cualquier otro.

Nuestro primer archivo de datos es como este:

____________________________________________
202548777102120545041
ESTO 1546564LOOTRO
202548345134534545451 EST2 1542344LOOTRO
202548777102120557087 EST3 1546789LOOTRO
752323654273654726534 EST4 2343344UNOMAS
112543456329324792347 EST5 5521973MASAUN
_____________________________________________

He marcado en el primer registro los campos de diferente color para que se diferencien cláramente (4 campos).

Para un archivo de ancho fijo podemos configurar la conexión (TADOConnection) de la siguiente forma:

Provider=Microsoft.Jet.OLEDB.4.0;Data Source=.\;
Extended Properties="text;HDR=Yes;FMT=Fixed";
Persist Security Info=False

Configuramos el proveedor como Jet 4.0, en este caso en directorio de la Base de Datois está definido como .\ (el mismo de la aplicación) y en las propiedades extendidas es donde realmente se define el tipo de archivo y la organización de los datos (Text y Fixed).

Sólo nos queda definir en el mismo directorio el fichero schema.ini donde detallaremos la estructura de las columnas de nuestro fichero. Éste sería un fichero correcto para este caso:

[datos.txt]
Format=FixedLength
ColNameHeader=False
Col1=ID char Width 21
Col2=Nombre char Width 6
Col3=Valor Integer Width 7
Col4=Descripción char Width 6
CharacterSet=ANSI

De esta forma podemos acceder a los datos del fichero mediante un TADOTable y trabajar con ellos utilizando todas las posibilidades que nos brinde este componente.

El ejemplo completo con el código fuente, el fichero de datos y el fichero de esquema se puede descargar desde aquí.

<Descargar ejemplo>

Continuación (parte2); Ficheros con datos delimitados por un separador.