Manejando bits con Harbour

En esta entrada del blog usaremos algunas de las funciones para operar con números binarios que nos aporta Harbour.

No entrare a explicar porque se usa el sistema binario en los ordenadores (supongo que como programadores es un tema que conocéis), y solo explicare brevemente el sistema binario, si ya lo conoces puedes saltarte el siguiente párrafo.

El sistema binario es un sistema de numeración en el cual los números se representan utilizando las cifras 0 y 1 . Cada dígito de un número en este sistema se denomina bit y al igual que en base 10 (el que utilizamos habitualmente), el valor depende de la posición donde se halla.

Veamos un ejemplo y nos quedará más claro:

Normalmente la manipulación de binarios queda reducida a la programación a bajo nivel, y en el resto de programación podemos sobrevivir sin manipular bits. Pero para poder ilustrar el uso de alguna de las funciones de manejo de bits de Harbour, os propondré el uso de binarios para la gestión de estatus, variables lógicas que solo puedan ser verdadero o falso, en nuestro caso 0 o 1.

Estos campos estatus habitualmente los solucionamos mediante el uso de campos lógicos, o tipo carácter de una posición grabando S o N, según corresponda. El tamaño de estos campos, o variables, es de 1 Byte (es el tamaño mínimo que podemos definir), pero 1 Byte son 8 bits, con lo cual el valor grabado en 1 Byte nos permite identificar hasta 8 estatus diferentes.

 Imaginemos que en una factura deseamos controlar varios estatus:

• Tiene IVA
• Tiene Recargo de Equivalencia
• Esta cobrada
• Esta impresa
• Es un contado
• Factura Rectificativa

Toda esta información podemos grabarla en un solo campo carácter de una posición, y aun nos sobra para dos estatus más.

Crearemos una tabla llamada FraCab que entre otros atributos, contendrá uno llamado Estatus del tipo carácter y de una posición.

Para el ejemplo trabajaremos sobre un único registro, y dispondremos de controles CheckBox para poder activar o desactivar nuestros estatus, que se grabaran en un campo de una sola posición.

Los ocho estatus los manejaremos mediante un Hash, por comodidad las tablas hash y algunas otras variables las he definido como estáticas al proyecto para no tener que pasarlas como parámetros.

Leeremos el campo estatus de la tabla y asignaremos a cada posición del hash el valor lógico que le corresponda. 

 Para este fin usamos la función hb_BitTest( nParam, nBit )→ lResult , le pasamos como primer parámetro el valor ascii de nuestro campo estatus y como segundo el número de bit que deseamos leer. hb_BitTest nos devuelve un valor lógico dependiendo si dicho bit vale uno o cero.

Una vez que hemos recuperados los valores de cada uno de los estatus, dibujamos el dialogo que nos permitirá ver y modificar los valores.

Para su modificación usamos controles CheckBox, que en el evento onChange, actualizan el campo, y refrescan los valores de la pantalla.

Esta es la función encargada de actualizar los valores

Recibe como parámetro la clave del hash, busca cual es su posición y lo graba en la variable nPos, esto nos permite saber que bit es el que debemos manipular.

Y procedemos a calcular el valor del nuevo estatus en función de si es falso o verdadero, mediante el uso de las funciones hb_BitSet y hb_BitGet

hb_BitSet( nParam1, nBit ) → nResult Retorna el entero resultante de activar el bit nBit en el entero nParam1

hb_BitReset( nParam1, nBit ) → nResult Retorna el entero resultante de desactivar el bit nBit en el entero nParam1.

Como podéis ver, necesitamos el código ASCII para pasar a la función de manipulación de bits, y convertimos el número obtenido a su valor ASCII, para ello usamos las funciones Asc() y Chr().

Este ejemplo ha sido programado usando FWH 15.01, Harbour 3.2.0 y BCC 5.82. Para su correcto funcionamiento es necesario linkar la libreria hbMisc.lib

Descarga código fuente
Descarga exe comprimido

 Espero que os haya resultado interesante, si además podéis extrapolarlo y hacer uso en algún caso práctico mucho mejor. Y en el peor de los casos deseo que os haya servido para conocer algunas de las funciones que incorpora Harbour y que no solemos utilizar frecuentemente.
Agradezco comentarios y sugerencias, saludos desde Mallorca.

Por cierto, en http://harbouradvisor.blogspot.com.es/2012/02/funciones-para-manipular-bits.html de mi amigo Carlos Mora, podéis encontrar una explicación de todas las funciones para manejo de bits que nos proporciona Harbour.

Setter y Getter, buenas prácticas en OOP.

Ha pasado muchísimo tiempo desde la última entrada, quizás demasiado, pero por aquí seguimos.

A diferencia de la mayoría de entradas de este blog, que son eminentemente prácticas, hoy haré una entrada más bien teórica.

Voy a hablar de los DATA ( variables de instancia ), a estas alturas todos hemos leído bastante sobre OOP (poo), y estamos familiarizados con su uso y bondades (polimorfismo, encapsulación, …).

Una de las costumbres habituales de los programadores de Harbour es manipular directamente las variables de instancia(los DATA de las clases), que es algo que va en contra de la encapsulación, pero también es cierto que nos vemos abocados a hacerlo porque muchas clases no disponen de métodos set y get o setget.

Lo normal y correcto es que los datas sean privados a la clase, y solo puedan ser manipulados desde sus métodos públicos.

Para ilustrar la importancia, lo haremos usando un ejemplo de código de la clase tAppl, que contiene, entre otras cosas, un data con los objetos font que se utilizan en la aplicación.

En su día este data se implemento usando un Array, y en la clase existían dos métodos uno para asignar y otro para recuperar.

Desde la aplicación, la clase se usa como ilustra el siguiente código, como podéis ver no se accede directamente a la variable, añadimos nuevos fonts usando AddFont y los recuperamos con GetFont.

Para facilitar el uso y la legibilidad del código, se realizaba un define para cada font del tipo

#define COUR10BOLD 3, que identificaba el font y tamaño con la posición del array.

Pasados los años en Harbour se incluyo el tipo de dato hash (arrays asociativos), que entre uno de los muchos beneficios que aporta, nos permite manejar de una forma más elegante estructuras de datos como el caso de los fonts.

La idea es sustituir el array que guarda los fonts por un hash, y cambiar la forma de recuperar el font, pasando como parámetro su nombre y no su indice, pero queremos mantener la compatibilidad con todas nuestras aplicaciones.

En este momento es cuando es importante el no haber manejado el data aFont directamente desde nuestras aplicaciones, ya que ahora cambiaremos el tipo de dato y la forma de recuperarlo.

La nueva forma de recuperar los fonts será oAppl:GetFont(“COUR10”)

Empezamos cambiando el nombre del data que pasa a ser hFont, solo este cambio rompería la compatibilidad si hubiéramos accedido directamente al data desde nuestros programas.

Inicializamos hFont en el método new(), hFont={=>}, hash vacio.

Y ahora pasamos a modificar los métodos AddFont y GetFont

En addFont hemos añadido un parámetro adiconal, que es el nombre por el que queremos recuperar el font ( la clave para el hash), como que este parámetro en la versión anterior no se pasaba, lo que hacemos es construirlo en el caso de que no lo recibamos como parámetro.

En GetFont, recibimos un nombre, o un indice numérico (para mantener compatibilidad). Comprobamos el tipo de parámetro recibido, si es numérico retornamos el font ubicado en la posición que indica el parámetro, de lo contrario retornamos el elemento cuya clave sea el parámetro recibido. Como posible mejora podemos comprobar previamente si existe la clave en la tabla hash, para evitar errores en tiempo de ejecución.(IF hb_hHasKey( ::hFont, uFont) )

De esta forma hemos modernizado nuestra clase tAppl para usar hash, manteniendo compatibilidad con las versiones anteriores.

Espero que este ejemplo haya ilustrado la importancia de definir Setters y Getters en lugar de acceder directamente a los datas de las clases.

Usando ficheros comprimidos ZIP desde Harbour.

Como pone en la página web de harbour (http://www.harbour-project.org/), harbour es software libre 100 % compatible con compiladores Clipper.

Pero ademas de las funciones Clipper, el compilador ha ido añadiendo una serie de funciones nuevas (todas las que su nombre empieza por HB_... ), que muchas veces desconocemos, y que nos aportan funcionalidad extra.
Estas funciones son usadas escasamente por la comunidad de usuarios, bien porque desconoce su existencia, bien porque la documentación es excasa o nula para poderlas usar.

En la entrada de hoy vamos a centrarnos sobre dos funciones en concreto, HB_ZipFile y HB_UnZipFile, que nos va a permitir comprimir y descomprimir archivos en formato ZIP.

HB_ZipFile( cZipName, cFile | aFiles, nLevel, bBlock, lOverRide, cPassWord, lWithPath, lWithDrive, pFileProgress )

cZipName	Nombre del fichero ZIP a crear
cFile | aFiles	Nombre del fichero a comprir o array de ficheros a comprimir. Unidad y Path pueden ser usados.
nLevel	Nivel de compresión. De 0 a 9
bBlock	Code block a ejecutar mientras se comprime
lOverRide	Sobreescribir el fichero si existe.
cPassWord	Password para encriptar el fichero ZIP
lWithPath	Guardar el path si/no
lWithDrive	Guardar la unidad si/no
pFileProgress	Code bloclk para progreso de archvios.

HB_UnZipFile( cFile, bBlock, lWithPath, cPassword, cPath, cFile | aFiles, FileProgress )

cFile	Nombre del fichero a descomprimir
bBlock	Code block a ejecutar a medida que se va descomprimiendo
lWithPath	Permitir crear directorios si es necesario
cPassWord	Contraseña a usar para descomprimir el fichero
cPath	Path donde estraer los ficheros
cFile | aFiles	Nombre de un archivo, o array de nombres de archivos a extraer
pFileProgress	Code block para visualizar progreso de los ficheros

Las dos funciones retorman un valor booleano, informandonos si el proceso a concluido con éxito.


Veamos un primer ejemplo sencillo de comprimir / descomprimir.


Vamos a complicarlo y elaborarlo un poco mas, en el fondo haremos lo mismo, pero con una barra de evolución tanto para comprimir como descomprimir. Simplemente haremos uso de los parametros adicionales que nos permiten ejecutar codeblocks.



Como podeis ver en el fuente, hemos creado dos funciones comprime y descomprime, que son muy sencillas de usar. Comprime recibe dos parámetros, nombre del fichero zip que queremos crear, y array (arreglo) con los ficheros que queremos comprimir. Descomprime recibe como único parámetro el nombre del fichero ZIP a descomprimir.
En el interior de cada una de las funciones creamos un dialogo para visualizar la evolución, y montamos e code block necesario para que se vaya actualizando.
Como visteis al principio existen más parámentros en la función HB_ZipFile y Hb_UnZipFile, se trata de que vayais experimentando con ellos y usando los que os hagan falta. Este ejemplo es un ejemplo básico, pero creo que cubre las necesidades más comunes de compresión y descompresión.

Existen una serie de funciones adicionales para manejo de ficheros Zip, pero os las dejo para que vosotros mismos las investigueis, en descomprime por ejemplo hacemos uso de hb_GetFilesInZip ,para determinar el número de archivos contenidos en el fichero comprimido.

Ya habeis visto que no es nada complicado, si solo quereis comprimir / descompriir, con dos funciones y usando dos parámetros ya lo esta listo.

El último escollo, pero también importante, es linkar las librerías adecuadas para poder hacer uso de las funciones de manejo de ficheros ZIP.
Las librerias a ñadir a vuestro proyecto son:
hbZiparc.lib
hbmzip.lib
hbzlib.lib

Descargar fuentes

Espero que os sea de utilidad, saludos desde Mallorca.
Biel Maimó

Actualización automática de aplicaciones

En la entrada anterior publique un sistema para realizar actualizaciones de nuestras aplicaciones via FTP. Hoy seguiremos hablando del tema, y le daremos otra vuelta de tuerca.

Para actualizar nuestra aplicación usábamos un pequeño programa “ActVer”, que se encargaba de renombrar y lanzar la ejecución de nuestra aplicación.

Al realizar este programa en [x]Harbour, nos queda de un tamaño bastante considerable teniendo en cuenta lo poco que hace, eso es debido a que como poco cualquier ejecutable Harbour se lleva dentro la maquina virtual.
Para mejorar el tamaño crearemos una versión de ActVer, pero escrita en C, con lo que pasaremos de los 1,46 MB de la versión de harbour a los 16 KB de la versión compilada en C (1,519,616 bytes menos).

Ademas para no tener que distribuir dos ejecutables, embeberemos ActVer.exe dentro de nuestra aplicación, concretamente en el fichero de recursos, y lo extraeremos solo en el momento que sea necesario actualizar nuestra aplicación.

El codigo de ActVer.C queda de la siguiente manera.

#include "stdio.h"
#include "windows.h"

int main( int argc, char *argv[])
{
Sleep(700);
DeleteFile( argv[1]);
rename( "tmp.exe",argv[1]);
WinExec(argv[1],1);
return EXIT_SUCCESS;
}

Ahora vamos a insertarlo dentro de nuestra aplicación, para ello añadimos la siguiente linea en nuestro fichero de recursos, xxxxx.RC

ACTVER RCDATA "ActVer.exe"

RCDATA nos permite insertar directamente datos binarios en nuestro ejecutable (graficos, otros exe, …)

Con esta linea, la siguiente vez que compilemos nuestra aplicación, actver quedara incrustado dentro de nuestro programa, ahora solo nos hace falta el poder extraerlo, cosa que haremos con el siguiente código (también en c).

Insertamos el código de la función en c, en nuestro fuente prg Harbour.

#pragma BEGINDUMP
#include "Windows.h"
#include "hbApi.h"
HB_FUNC( RESTOFILE )
{
HRSRC res=FindResource(NULL,"ACTVER",RT_RCDATA);
LPDWORD bytesWritten;
int size=SizeofResource(NULL,res);
HGLOBAL hRes=LoadResource(NULL,res);
unsigned char *pRes=(unsigned char *)LockResource(hRes);
HANDLE hFile=CreateFile("ACTVER.EXE",GENERIC_WRITE,0,NULL,CREATE_ALWAYS,0,NULL);
WriteFile(hFile,pRes,size,&bytesWritten,NULL);
CloseHandle(hFile);
}
#pragma ENDDUMP

Y con esto ya veis que es muy sencillo el incorporar ficheros binarios en nuestro EXE, esta es una posible utilidad, pero seguro que le encontrareis alguna otra.

Para que el PRG de nuestro anterior hilo incorpore esta funcionalidad, debemos añadir el codigo antes citado, y realizar una llamada a la función ResToFile() en la linea anterior a WinExec.

UpdFtp2.prg
ActVer.c
UpdFtp2.zip contiene UpdFtp2.exe
ActVer.rc
ActVer.Exe

Actualización automatica de aplicaciones via FTP

En esta entrada del blog vamos a diseñar un sistema para automatizar las actualizaciones de las versiones de nuestros programas.
Para ello, necesitaremos disponer de un servidor FTP. El motivo de usar un servidor FTP, es que nos va a permitir tanto una solución vía intranet como Internet.

Vamos a explicar la teoría de este sistema, y después iremos con la practica y el código fuente.

1º Dispondremos de un servidor FTP, en el cual montaremos una estructura de carpetas, donde el nombre de la carpeta, será el de la aplicación, y dentro de esta carpeta alojaremos la última versión de nuestro programa ejecutable.

2º Especificaremos a nuestro programa, la información necesaria para poderse conectar al servicio FTP( ip, usuario,...), con esa información se conectara, y comprobara la antigüedad del fichero alojado en el servidor, la comparara con él mismo, y si la versión del FTP es más nueva, procedera a la descarga del fichero ejecutable, en un fichero temporal en nuestra unidad local.

3º Si había actualizaciones para descargar, y la descarga se ha completado con éxito, ejecutaremos otro proceso, que borrara la versión antigua, re nombrara y lanzara su ejecución.

Y con esto ya tendremos actualizado nuestro programa. Viendo la teoría, no parece muy complicado ;-)

Esta solución, la tengo implementada como parte de una clase (tAppl), que utilizo en todas mis aplicaciones, aquí para poderos poner un ejemplo auto contenido, y no complicarnos explicando la creación de las clases, lo realizaremos con funciones, aunque luego el lector lo podrá adaptar a una clase o de la manera que le parezca mas cómoda para su forma de trabajo.

Nuestra aplicación, empezara definiendo la dirección del servidor FTP, y la carpeta donde comprobar el fichero a actualizar, seguidamente ejecutaremos la función ChkUpdFtp, y aquí se bifurcara, dependiendo de si hay que actualizar o no.

Veamos ahora la función(ChkUpdFtp) encargada de determinar si existen versiones nuevas de nuestro programa, para ello utilizaremos las clases tInternet y fFtp.
Lo primero que haremos será comprobar si disponemos de los parámetros necesarios para conectarnos, y si existe el programa ActVer(mas adelante veremos su código fuente) que será el encargado de renombrar y relanzar nuestro programa. Pasado este primer filtro, pasamos a intentar realizar la conexión con el FTP, si dicha conexión tiene éxito, solo nos resta comprobar las fecha y hora de creación de los archivos y determinar si debe o no actualizarse, en caso de que se deba actualizar llamaremos a la función Actualiza.

En este proceso usamos funciones que no vamos a comentar su funcionamiento, simplemente os incluyo su codigo fuente (prg y C). ( TimeToSec, FileTimes, FileSize ) O bien podeis utilizar alguna alternativa vuestra si en vuestro set de funciones ya las teneis definidas.

La función actualiza, es la encargada de descargar el nuevo fichero ( GetFile ), y visualizar en pantalla una barra de evolución de la descarga .


Al llegar a este punto, si la función Actualiza nos devuelve verdadero, significará que ya tenemos descargado nuestra nueva versión en la carpeta local, solo debemos cerrar la versión actual, e invocar ActVer que se encargará de borrar la versión anterior, y renombrar el fichero que acabos de recibir, y posteriormente ejecutarlo.

Veamos el sencillo código de ActVer.exe, recibe como parámetro el fichero a actualizar, borra la versión anterior, renombra y ejecuta.

Y con esto ya tenemos implementado nuestro sistema de actualizacion via Ftp de nuestras aplicaciones.
Dos cosas importantes a tener en cuenta si vuestro servidor de FTP es LINUX, los nombre de ficheros, en linux son case sensitive, y la hora de creacion del fichero se guarda en UTC.
UpdFtp.prg
ActVer.prg
UpdFtp.exe y ActVer.exe

Nota: me comentan que al compilar con xHarbour falta la función HB_IsChar, simplemente sustituir HB_ISCHAR( cTime ) por ValType(cTime)=='C'.

Multi Idioma con [x]Harbour + FiveWin

   En esta ocasión vamos a implementar un sistema multi idoma, basado en DLL de recursos. Esto os podrá servir para distribuir vuestras aplicaciones en diferentes países, o en un mismo país con diferentes idiomas. En Baleares al igual que en otras comunidades autonomas de España, existen dos idiomas cooficiales, Castellano y Catalán. Es habitual, y sobre todo en organismos públicos que soliciten las aplicaciones en multi-idioma, o directamente traducidas al Catalán.

Para solventar este problema, sin que tengamos que modificar los fuentes de nuestra aplicación, ni debamos mantener varias versiones en paralelo, lo que haremos sera mantener tantas DLL de recursos como idiomas queramos disponer en nuestra aplicación. 

Para ello contaremos con una DLL de recursos vaciá ( vacio.dll ), que usaremos como base,  e iremos introduciendo los diálogos, y crearemos un "string table" con los mensajes que utilicemos en nuestra aplicación. (Para editar las DLL usaremos un editor de recurso cualquiera, en nuestro caso el que viene integrado con PellesC)



La tabla de cadenas tiene un formato parecido al siguiente, un código y su mensaje asociado. Desde nuestro programa iremos recuperando las cadenas de texto por su numero de código.


La idea es al principio de la aplicación cargar la DLL que queramos según el idioma seleccionado, y automáticamente tendremos los diálogos y cadenas de texto en el idioma deseado.
La carga de la DLL deseada la hacemos mediante la función SetResources( via de acceso + nombre de fichero.dll), el nombre y la via de acceso puede estar guardada por ejemplo en el registro de windows, un fichero ini, o directamente solicitar la elección del idioma por parte del usuario.

En su día tuve la idea de usar Shell.Applucattion y las extensión de NTF, para grabar junto a la DLL la descripción del idioma, pero resulto ser un fiasco, debido a que solo funciona con NTF, y en instalaciones con FAT32 no funciona, y ademas al comprimir o hacer paquetes de instalación, se pierde la información adicional de los ficheros, a modo de curiosidad, y para el que quier ver los fuentes y el manejo de Shell.Application, aquí os dejo los fuentes.

Recapitulando, al iniciar el programa, cargamos la DLL de recusos deseada
Ejemplo:
oAppl:cLng:=GetLng() //Funcion que recupera el idioma
SetResources(oAppl:cDirLocal+"Resource\ppcinst"+oAppl:cLng+".dll")
oAppl:hDll:=GetResources()
Los diálogos, ya los tenemos traducidos directamente en el diseño del recurso.
Para recuperar las cadenas de texto, usaremos la función LoadString(hDll, nResid ), le debemos pasar dos parametros, el primero es el handler del modulo que contiene las cadenas de texto, y el segundo el codigo de la cadena que quermos cargar.
LoadString( oAppl:hDll, 10001 )

Para hacerlo más fácil de leer y manejar, os recomiendo crear un fichero CH para incluir en vuestro programa, a modo de diccionario, donde iremos definiendo un texto mas legible asociado a la función y código de cadena a recuperar.




De esta forma por ejemplo visualizar un mensaje avisando de que la aplicación ya esta en ejecución pasaría de un críptico

MsgStop( LoadString( oAppl:hDll, 10001 ) )
a
MsgStop(TXT_EXERUNNING)

bastante mas descriptivo.

Aquí os pongo un pequeño ejemplo para ver el funcionamiento de lo descrito anteriormente.


MultiLng.prg
MultiLng.zip

Un año de vida del Blog

Como pasa el tiempo, parece que fue ayer mismo cuando escribí la primera entrada de este blog, y ya ha pasado mas de un año desde esa primera entrada.

Desgraciadamente, y por falta de tiempo no he podido escribir todo lo a menudo que hubiera deseado, pero el tiempo disponible es finito, y el blog de momento no nos da de comer ;-).
En un primer momento pensaba escribir mucho mas sobre ADO, pero la realidad es que el trabajo es el que marca un poco el rumbo y la tendencia de este blog, y se alimenta de las investigaciones personales que tengo que ir realizando en base a los requerimientos de los proyectos que este desarrollando.

El tema ADO no queda abandonado, pero si un poco aparcado, de todas formas en este periodo, han ido apareciendo muchos buenos aportes sobre ADO y xBase (ADOBASE, SQLWIN, ...) y en el foro no estamos tan huérfanos de información como antaño.

En este año, el número de visitas,y comentarios ha ido creciendo progresivamente, aunque no es un volumen bestial, si me alegra el ver que va en aunmento, y ademas cuenta con lectores fieles. Como digo, eso me alegra, y ademas es el motor y el combustible necesario para animarme a seguir escribiendo.

Pues nada mas, simplemente agradeceros a todos vuestra lectura, comentarios, desear que os haya sido de utilidad, y espero seguir contando con vuestra visitas.

Un abrazo. Y hasta la proxima entrada, que será muy pronto e ira de multi-idioma con xHarbour y DLL de recursos.

Reunión xBase en Barcelona

A diferencia de todas las entradas previas, esta no os va a aportar ningún código fuente, ni ninguna explicación de como hacer tal cosa,... En este caso esta entrada es puramente bloguera, y para contaros un poco mi vida. Jaja intentare no ser muy pesado;-)


El mes pasado, y a iniciativa de Carlos Aubia, hicimos una mini reunion en Barcelona. La idea inicial salio de este mismo blog, y del hecho que tanto a Carlos como a mi nos apetecia, conocernos y compartir conocimientos e inquietudes(hasta la fecha solo habíamos cruzado varios mails, y comentarios en los foros).

Todo fue muy rápido, decidir lugar, buscar ofertas de vuelos para fijar fecha, y listo. Decidí viajar yo, ya que al vivir en Mallorca, tengo derecho a descuentos del 50% en vuelos para paliar el hecho de nuestra insularidad.

Sobre la marcha pensamos que si nos juntásemos unos cuantos, pues mucho mejor y decidimos invitar a unos pocos amigos.
La verdad que ante lo precipitado de la reunion, no pensabamos que fuese a apuntarse nadie, y tampoco se trataba de hacer una macro convocatoria. Al final los asistentes fuimos Carles Aubia, Carlos Mora, Rafa Carmona, Andres Gonzalez, y el que suscribe.
Lo primero de todo, dar las gracias a nuestro anfitrión (Carles) y a su empresa (Bayer), por poner a nuestra disposición tan magnificas instalaciones.


Fuimos llegando a Sant Joandespi, por diferentes medios, mención especial Carlos y Andrés que se pegaron una panzada importante de autobus. A los pies del edificio de Bayer nos conocimos todos, era una situación peculiar, pues todos nos conocíamos por el cyberspacio, pero salvo excepciones, nunca nos habiamos visto en persona. (Carles conoía a Rafa, Rafa a Carles y a Carlos, Andres me conocía a mi).

Hechas las presentaciones, y acreditaciones, subimos a la sala de reuniones que Carles tenía reservada, y empezamos la reunión. No habíamos fijado un orden, ni unos temas concretos para hablar, puesto que la idea inical era el vernos Carles y yo. La verdad es que para una próxima reunión, quizas sea interesante el preparar un guion y unos temas prefijados.

Estuvimos hablando de muchísimas cosas, imposible resumirlas en esta entrada. Compartimos las formas de trabajo, como afrontar los problemas en el desarrollo, viendo los desarrollos propios de cada uno, hablando del pasado, del presente, del futuro de xBase, de cual creemos es el camino a seguir,bueno un sin fin de cosas.

Entre las cosas que vimos, enumero unas cuantas:

- Entorno de desarrollo, vimos y comentamos el funcionamiento de xMate y de uStudio

- LetodDB y ADS, letoDB es un tema de moda últimamente, y ADS es un clasico y una realidad para acceso C/S contra DBF, estuvimos haciendo unas pruebas con ADS usando xBrowse contra un servidor remoto en Lisboa.

- Por supuesto no podía faltar Internet, se comentaron experiencias con SOAP, y una implementación de CGI con xBase.

- Linux, compilación multiplataforma, gestión de eventos y forma de procesar los mensajes del SO.

- Control de versiones, uso de SVN.

- Pocket PC, conexión vía GPRS y envio de datos via FTP

- Editor de pantallas, uso de recursos. Diferenntes maneras de afrontar el problema de no tener un IDE, ni un editor de pantallas mas completo en el cual poder asignar mas propiedades a los objetos.

Y seguro que se me escapan, ya en contactos más individualizados se estuvieron comentando otros cosas, aplicar temas de windows a controles, uso de FreeImage, capturar métodos y propiedades de componentes ActiveX, WMI, ...

De izq a drch, de pie Carles Abuia, Rafa Carmona"thefull", Andrés Gonzalez, sentados yo mismo, Carlos Mora.

De la reunión saque algunas conclusiones:

- Que la gente tiene ganas de hacer reuniones, charlar, compartir, ver lo que hacen el resto con las mismas herramientas. Tenemos la intención firme de montar una reunion nacional de usuarios, posiblemente en Madrid, de ello ya informaremos cuando lo tengamos perfilado.

- Que aunque el grupo de usuarios de xBase esta más bien en declive, sigue habiendo grandes profesionales trabajando en este entorno, y me siento afortunado de haber podido conocer y compartir un dia con unos cuantos craks de este entorno.

- Todos trabajamos con la librería FiveWin, aunque también casi todos, hemos probado o probamos otras GUI existentes (vease Xailer, MiniGui, ...), es un sentimiento común que aunque no nos es estrictamente necesario, un IDE le vendria muy bien.

-Esto no es una conclusión, más bien dudas, hacia donde ira Harbour cuando el objetivo incial de compatibilidad y estabilidad esten cumplidos.


Y eso es todo, no quiero alargarme más, pues todo un día de reunión da mucho de si.


Espero veros a todos en la próxima reunión, que se celebrará ... (pendiente fecha y luggar)

LetoDB (RDD cliente servidor para [x]Harbour)

Hasta ahora la mayoría de entradas de este bloc, hacen referencia al acceso a datos mediante el uso de ADO, como alternativa al uso clásico de los ficheros DBF.

En esta nueva entrada, nos vamos a quedar en medio de la dos tecnologías, y hablaremos de un proyecto Open Source creado por Alexander S. Kresin, llamado LetoDB.

LetoDB, es un servidor de base de datos multi plataforma(Windows y Linux), escrito en Harbour y que nos permite trabajar con ficheros DBF e indices CDX o NTX. Se implementa como un RDD de harbour, y por tanto la forma de usarlo es prácticamente igual que usar DBFs de toda la vida, solo nos harán falta unas pocas instrucciones para realizar la conexión al servidor.

LetodDB se divide en dos partes fundamentales, el servidor (letodb.exe) y la parte cliente (rddleto.lib). También se incluye un programa de consola, que nos permite monitorizar el estado del servidor.
Aunque el tema es amplio y habría mucho que comentar sobre la implementación del servidor, el uso de multihilos, etc, como siempre intentare ser eminentemente práctico, y que de una manera rápida y senciilla podáis probar ester servidor, y si os interesa el tema vosotros mismos podréis ir profundizando.

Para empezar nuestras pruebas, deberemos descargarnos una serie de archivos, aunque os los podéis descargar de sourceforge (http://sourceforge.net/projects/letodb/ ) y compilarlos con la version que deseeis, aquí os pongo un enlace para que os podeis descargar un fichero en el que ya estan los ejecutables y la librería listas para usar.

Descargar letodb.zip
Este archivo contiene lo siguiente
Letodb.exe ->Ejecutable del servidor
rddleto.lib -> RDD (compilado con Harbour 1.0.0RC1(Rev.8835) )
manage.exe -> Consola del servidor.
Una vez tengamos descargado este archivo, podemos crear una carpeta (C:\letoDB por ejemplo), y descomprimimos letodb.zip.

El servidor de LetoDB, por defecto trabaja sobre el puerto 2812, y el path por defecto es c:\, estos parametros pueden ser modificados mediante el uso del fichero letodb.ini, si no existe este fichero, se utilizaran los valores por defecto, y si existe los tomara del fichero. Debe crearse en la misma carpeta donde se encuentra ubicado letodb.exe.
Ejemplo letodb.ini

Port = 2812
DataPath =c:/letodb
Logfile = "letodb.log"
Default_Driver = CDX

Para arranncar el servidor, simplemente ejecutaremos letodb.exe, el servidor no tiene ventana asociada, y solo nos arrancara un proceso en nuestro sistema. Para detener el servidor, ejecutaremos el “letodb stop”.


Ahora ya podemos arrancar la utilidad de consola, que nos va a permitir monitorizar nuestro servidor. Para conectarnos al servidor, debemos especificar la IP donde esta letoDb ejecutandos, el port que usamos y pulsar sobre el boton Go. Si lo estamos ejecutando en local sobre nuestro PC, en la dirección pondremos 127.0.0.1 o bien localhost.
El tercer campo que por defecto tien 2 como valor, son los segundos que tarda en refrescar la información.


Una vez hemos pulsado GO, dispondremos de tres vistas, que podremos ir cambiando pulsando los botones Main, Users, Tables. La información de cada una de estas pantallas es autoexplicativa, en la primera información general del servidor, en Users veremos los usuarios y procedimientos conectados, y en Tables veremos cada proceso con los ficheros que tiene abiertos.

A estas alturas ya estamos listos para escribir el código fuente que nos permita conectar con el servidor letoDB, y realizar nuestras primeras operaciones cliente servidor usando ficheros DBF.

El código fuente es el siguiente, y para que funcione tenéis que linkarlo junto con RddLeto.lib, y por supuesto el servidor debe de estar ejecutándose.



Como podeis apreciar prácticamente todo son comandos estándar de harbour, el único comando no estándar es el que nos comprueba si tenemos conexión con el servidor, el resto son todos nativos de Harbour.
Observar también que debemos definir la dirección IP y el puerto que uso nuestro servidor LetodDB.
El ejemplo es muy sencillo, todo el código esta comentado y creo que se entiende perfectamente.
Ademas de los visto, letoDB incorpora otras funciones adicionales, pero que ya podréis descubriendo si os interesa este sistema cliente servidor, entre las cosas destacadas comentaros que incorpora control de transaccional ( leto_BeginTransaction(), leto_Rollback(), leto_CommitTransaction()), y que el autor tiene pensado en un futuro implementar procesos almacenados que estarán escritos en Harbour.

Desde aqui podeis descargar el código fuente, y el ejecutable.
Descargar ejecutable
Descargar código fuente
Descargar letodb.zip
Podréis encontrar más información sobre letoDB, y descargaros el proyecto completo con su código fuente en sourceforge (http://sourceforge.net/projects/letodb/ )

Ya que son varios los que me lo habeis pedido, aqui os pongo un fichero .bat y .bc para que podais construir la libreria y el ejecutable del servidor con Harbour(1.0.0RC1)y Borland C 5.5, para versiones anteriores de Harbour no vale, ya que se han renombrado las libreriras. Estos ficheros asumen el compilador de C en C:\Borland\bcc55\bin y Harbour en c:\harbour. Si los tienes así, copia estos dos archhivos en la carpeta donde te has descargado letoDB(desde sourcefourge)y basta con ejecutar make_b6 desde la linea de comandos(Si quieres asegurarte de limpiar copias antiguas, ejecuta primero make_b6 clean).
Descargar make_b6.bat
Descargar makefileb6.bc



Gracias a Alex Kresin, y a todos los que han contribuido en el desarrollo de LetoDB, que nos brinda otra alternativa de acceso a datos para el mundo xBase.

Saludos desde Mallorca.



...

Instalador para Pocket PC

Hasta la fecha las instalaciones de nuestras aplicaciones para PDA, las esta haciendo de una manera bastante rudimentaria y manual.
Estuve buscando por la red algún buen programa de instalación y que ademas fuera gratuito. No encontrando un software que me satisfaciera al cien por cien, recorde que habia leido en algun post del foro de FiveWin, como hacer ficheros de instalacion para PDA, usando CabWiz y EzSetup (ambos freeware).

Busque y encontre toda la documentación necesaria, parte en el foro de FiveWin (gracias a Pawel y Carles Aubia), y otra en el MSDN.

Aunque CabWiz y EzSetup funcionaban bien, la verda es que era algo engorroso el crear las instalaciones. Y aqui empezo este proyecto, se trataba de tener un gestor de scripts de instalación basados sobre CabWiz y EzSetup, pero que ademas fuese sencillo de manejar.

Y este el resultado final del instalador, aunque seguro que mejorable en muchos aspectos, para mi cubre las necesidades basicas de instalador.
El funcionamiento es muy sencillo e intuitivo, tenemos los siguientes campos
Proyecto: Es el nombre con el que se guardara el proyecto
Fichero ejecutable: Es la via de acceso y el nombre del fichero exe de la aplicacion que queremos general el setup.
Carpeta de datos: Es la carpeta que contienes los datos de nuestra aplicación, esta carpeta se creara con el nombre \DATOS y colgara de la carpeta de la aplicación(por ahora no es configurable). Todos los archivos que se encuentren en la ruta se copiaran.
Proveedor : Nombre de nuestara empresa
Nombre Aplicacion : eso

En la PDA nuestra aplicacion se instalara en la carpeta cuyo nombre sera la concatenacion de Proveedor + Nombre Aplicacion

Ahora tenemos cinco pestañas.
1.- Readme, texto que aparecera en la primera pantalla del setup
2.- Eula, condiciones de licencia de nuestro software, aparece en la segunda pantalla del setup, y debe aceptarse.
3.- Carpeta Comun, aqui estara nuestro fichero ejecutable, y podemos añadir otros ficheros manualmente.
4.- Carpeta datos, es solo lectura, y veremos que archivos seran copiados en la carpeta datos.
5.-My Documents, Nos permite añadir manualmente archivos que serán copiados en My documents de la PDA.

Los botones de la barra por orden de aparicion :
Nuevo,Recuperar un proyecto guardado, guardar proyecto actual, generar instalación, salir.

Cuando puslamos sobre el boton generar instlación, obtendremos como resultado el fichero setup.exe que es el que deberemos ejecutar en nuestro pc con el terminal conectado mediante ActiveSync, e instalara nuestra aplicacion en el Pocket PC.


Y con esto creo que esta casi todo explicado, aqui está el link para descargarel programa.
Descargar Setup.exe

Para los usuarios de Windows vista debeis istalar "Centro de dispositivos de Windows Mobile" que viene a ser el sustituto de ActiveSync, lo podeis descargar desde la página de Mircosoft.
Centro de dispositivos de Windows Mobile 6.1 para Windows Vista (32-bits)

Espero que os pueda ser util.
Saludos, y hasta la proxima.

Usando origenes de datos ADO y 2

Desde febreo no públicaba nada en el blog, y es que el trabajo estos últimos meses ha sido más intenso.
Para esta segunda entrega tenia pensado implemenar al ejemplo que hizcimos en la entrada anterior, autosort por columnas, y busqueda incremental para la descripción.

El tema del autosort, en la versión actual de FiveWin, xBrowse ya lo incluye nativamente, ademas de DATAS para el manejo del orden, con lo que en realidad no nos sera muy util si estamos usando FiveWin actualizado, y será meramente educativo, aunque si estais en versiones antiguas de FiveWin os permitira implementar esa funcionalidad.

Para hacer las ordenacines de campos y las busquedas, utilizaremos el Data Sort y el metodo Find del obbjeto RecordSet. El ámbito, serán los registro que formen parte de nuestra consulta SQL, y tiene como ventaja que no genera trafico con el servidor(con una sentenica SQL podriamos conseguir el mimsmo resultado, pero cargariamos proceso al servidor y generariamos tráfico en la red).

El data Sort ordena uno o varios campos del Recordset de forma ascendente o descendente. Para ello debemos asignar una cadena a esta propiedad con el nombre o nombres de los campos a ordenar, separados por comas e indicar el modo de ordenación mediante las palabras claves ASC o DESC.
oRs:Sort:="CliDes ASC"
Ordenado por el campo CliDes de forma ascendente.
El metodo Find busca un registro en función de un criterio. Si el criterio se cumple, el registro localilzado pasa a ser el actual, en caso contrario el Recordset se sitúa al final.
Su sintaxys:
oRs:Find( cCriterio, SkipRecords, DireccionBusqueda, Start )
En el criterio no puede usarse OR ni AND, y solo puede aparecer uno de los siguientes operardores = > >= < <= <> LIKE .

Pasemos a la acción, vamos a usar practicamente el mismo código que en la entrada anterior, con algunos añadidos.
En la parte donde creamos el fichero MDB, y lo rellenamos con datos de prueba, el campo descripción lo rellenaremos con valores alfabéticos aleatorios para poder probar las busquedas incrementales.
FOR x:=1 TO 20
cCliDes+=Chr(HB_RandomInt(65,70))
NEXT
oRs:Fields("CliDes"):Value:=cCliDes

Para poder realizar la busqueda incremental, necesitamos un objeto SAY, y una funcion que realice la busqueda y nos devuelva verdadero o falso según el resultado de la busqueda.

oBar := TBar():New(oWndVerMdb,50,45,.T.)
@ 01,10 SAY oSay PROMPT '' SIZE 90,20 OF oBar
Creamos una barra, y dentro de la barra colocamos el SAY que visualizara la cadena que estamos buscando.

Y ahora le indicamos al browse el objeto SAY y la funcion que procesara la busqueda.

oBrw:bSeek := { | c | Busca(c,oRs) }
oBrw:oSeek := oSay

Y la función encargada de realizar la busqueda es la siguiente.

La función recibe dos parámetros, la cadeana a buscar, y el objeto recordset(podriamos mejorar la función y pasarle como parametro el campo sobre el que queremos hacer la busqueda). Montamos la cadena de busqueda dependiendo de si es el primer caracter tecleado o no, y se lo pasamos al recordset. Buscamos en el campo CliDes que empiece por la cadena que recibimos como parametro mas cualquier otra cosa( LIKE "cadean busqueda"+"*").
Si no es inicio o final de fichero significa que hemos encontrado un regitro, y devolvemos verdadero.

Con esto ya tenemos implementada la busqueda incremental en el browse.

Pasemos ahora a añadire la opcion de ordenar los registros cuando pulsamos sobre la cabecera de la columna.

Despuese de la instruccion SetAdo(), añadimos la siguiente linea, donde le indicamos un codeblock a ejecutar cuando se pulsa con el raton en la cabecera.
AEval(oBrw:aCols,{|oCol|oCol:bLClickHeader:={|f,c,h,oCol|Ordena(oBrw,oRs,oCol)}})
Y la fucion encargada de controlar el orden es la siguiente

En esta función casi nos lleva mas trabajo el ir colocando el BMP de la flecha arriba abajo, que realizar la ordenación. Si no visualizamos el BMP Ordena quedaria reducido de la siguiente manera:
STATIC FUNCTION Ordena(oBrw,oRs,oCol,cFld)
LOCAL cSort:=oRs:Sort,nLen,nFor
oRs:Sort:=cFld+IF(At(cFld,cSort)>0,IF(At('ASC',cSort)>0,' DESC',' ASC'),' ASC')
oRs:Sort:=cFld+Space(1)+oCol:cOrder
oBrw:GoTop()
RETURN NIL

La funcion VerMdb, con las lineas que hemos añadido para la busqueda y la ordenación de columnas, queda de la siguiente manera:

Desde aqui podeis descargar el código fuente, y el ejecutable.
Descargar ejecutable
Descargar código fuente
Como siempre, espero que os haya resultado amena la lectura, y ademas os pueda ser de utilidad.
Saludos desde Mallorca.
(ADO RecordSet Harbour xHarbour FiveWin oRs.Find oRs.Sort)

Usando origenes de datos ADO 1

En esta entrada, voy a incluir un ejemplo autocontenido en el que vamos a abrir un origen de datos via ADO, y visualizaremos su contenido en una rejilla (xBrowse).
Para tal efecto, y para que no sea requerimiento tener algun servidor instalado, utilizaremos un fichero MDB (Microsoft Access), dicha base de datos la crearemos dinamicamente desde nuestro código, haciendo uso de los componentes ADOX (Active Data Objects Extension).
Para que fucnione, debemos tener instalado en nuestro ordenador el proveedor de datos Microsoft.Jet.OLEDB.4
Descargar ejecutable
Descargar código fuente

Este programa consta de dos partes, la primera parte donde creamos la base de datos, la tabla, y rellenamos con datos de prueba, que corresponde la siguiente porción de código, la cual no creo que haga falta comentar, puesto que con la lectura y los comentario en el propio código fuente, es autoexplicativo.


Como podeis ver creamos un catalogo, despues una tabla, añadimos campos a la tabla, definimos la clave primaria, y finalmente añadimos la tabla al catálogo.


En esta segunda funcion, definimos un objeto connection, creamos un recordset, definimos CursorLocation del lado del cliente (salvo contadas excepciones, siempre los definiremos del lado del cliente), tipo de cursor Dinamico (aqui si que tendremos más juego dependiendo de las operaciones que queramos realizar con los datos), tipo de bloqueo (en este caso optimista), le indicamos cual es el objeto connection que debe usar, y la sentencia SQL a ejecutar.
Una vez abierto, mediante un bucle FOR ... NEXT vamos creando registros de prueba.

Cuando ya tenemos creado nuestra base de datos access, lo único que nos resta es visualizar los registros que le hemos incorporado.
Con muy pocas instrucciones podemos ver en pantalla todos los registros, en esta primera entrega, solo visualizaremos los registros no haremos ninguna funcion de mantenimiento, si bien en la fucnion CrtTstDat, ya podeis ver como funciona la mecánica para añadir registros.

En la función VerMdb, recuperamos todos los datos contenidos en la tabla Cliente, y los visualizamos en un Browse. Con solo diez lineas es suficiente, y eso en parte es gracias al uso del metodo SetAdo(aportación personal donada a FiveTech) de la clase xBrowse que nos crea las columnas y nos configura los codeblock de movimiento (bGoTop, bGoBottom, bSkip, ... )


Espero que os sea de utilidad, espero vuestros comentarios.
Saludos.

(ADOX:Catalog ADOX:Table ADOX:Key ADODDB:Connection ADODB:RecordSet tXBrowse SetAdo )

TreeView con xBrowse

Aunque muchas aplicaciones usan la visualizacion tipo arbol, la verdad es que hasta la fecha nunca lo habia usado en mis programas.
Esta vez tenia muy claro el resultado que queria obtener, pero ni idea de como llegar hasta el.
Queria visualizar un plan de cuentas, con una estructra arbolada a la izquierda y una rejilla con las cuentas a la derecha.


Este es el resultado final, y es justo como deseaba que quedase ;-).
La tabla cta esta formada por los siguientes atributos:
CTA Caracter 8
NOM Caracter 45

Y los registros están grabados tal cual se ve en la imagen superior.

Para conseguir nuestro proposito usaremos un splitter vertical, colocando un objeto TreeView a la izquierda y un xBrowse a la derecha.
Creamos el objeto oTree del tipo TreeView
oTree:=TTreeView():New(0,0,oWnd,,,,,300)
y lo procedmos a rellenearlo con los datos que deseamos, para ello llamos a la función AddMayor, pasandole como parametro el propio objeto oTree, y un array vacio(paso el array desde esta funcion para poder darle algun tipo de uso futuro, ahora mismo no lo uso para nada, y podriamos prescindir de pasar el arraym y crearlo como una variable local en la función AddMayor).


En esta función uso un indice condicional 'mayor', que solo contiene las cuentas de mayor y no las subcuentas.
Lo que hago es recorrer todo el fichero, e ir agregando nodos al objeto oTree, la forma de agregar varia si estamos en el nodo raiz, o añadimos a uno ya existente.
Si la longitud del contenido del campo cta es 1, estamos en el nodo raiz, añadimos el elemento con el metodo Add del objeto oTree, que devuelve otro objeto del tipo tvItem.
oTree:Add(AllTrim(Cta->Cta)+' '+Cta->Nom)
Mientras que si no estamos en el nodo raiz(long. cta>1), lo que hacemos es utilizar el metodo Add, pero del objeto tvItem correspondiente.
Buscamos en el array el item que corresponde al valor de cta actaul menos una posicion, y si le añadimos el nuevo elemento con la siguiente instrucción.
aItems[nPos,2]:Add(AllTrim(Cta->Cta)+' '+Cta->Nom,,AllTrim(Cta->Cta))

A medida que voy creando los nodos, guardo el objeto tvItem y el valor de Cta en un array. Este array lo utilizo para posicionarme en el nodo correcto mediante la funcion Ascan.

Si os fijais en cada elemento de cada nodo del objeto tree es un objeto tvItem, el objeto tvItem dispone de un data llamado cargo (presente en muchos otros objetos) que esta diseñado para guardar cualquier dato que quiera el programador, en nuestro caso, grabamos el valor del campo Cta, y nos va a servir para hacer un Scope en el browse, a medida que nos vayamos desplazando por el arbol.
Para conseguirlo usamos el data bChanged, en el cual colocamos un codeblock que sera evaluado cada vez que haya un cambio en el objeto oTree,



Este CodeBlock, recupera el elemento seleccionado del oTree, comprueba que no este vacio el Data Cargo, aplica el scope a la tabla, reposiciona y refresca el objeto browse.

El resto de trabajo que nos queda es definer el browse y el spliter, que supongo que todos ya sabreis perfectamente como hacerlo.


Es importante el data nLeft del objeto browse para que quede a la derecha del splitter, y el codeblock bResized de la ventana, para que se reajuste el splitter si cambia el tamaño de la venana.

Espero que os haya gustado la lectura, y os pueda ser de utilidad, todos los comentarios son bienvenidos.

(tTreeView tVItem tXBrowse oTree:bChanged SetRDD )

tDataBase, usando tablas como objetos.

Puede que pienses que esto no tiene nada que ver con ADO, y en efecto directamente no tiene nada que ver con ADO. En una entrada anterior comentamos que para trabajar con ADO, era necesario conocer algo de SQL, lo que no compentamos es que tambien es necesario manejarse bien con la programación orientada a objetos (POO).

En FiveWin está incluida un clase que nos permite manjear las tablas DBF como objetos, eso nos permitiira por una parte probar y tomar soltura en el manejo de propiedades, metodos y ademas es una forma muy eficaz de trabajar.

Esta clase nos controla los bloqueos de registro, incorpora un buffer para no modificar directamente sobre el registro, controla si hay cambios en los datos editados, y muchas mas cosas, que nos llevaria bastante trabajo programar a mano.

Su uso es muy sencillo, y ahora veremos un pequeño ejemplo.

El primer paso, es crear el objeto (instanciar de la clase), abriremos una tabla, por ejemplo de proveedores

DBUseArea(.T.,'DBFCDX','PROVEEDOR','PROVEEDOR,.T.,.F.)

oDbf := TDataBase():New()

ya tenemos creado y funcional nuestro objeto oDbf, disponemos de todos los metodos necesarios para trabajar con una tabla (oDbf:Skip(), oDbf:GoTop(), oDbf:Save(), oDbf:Used(), ...), en la ayuda de fivewin encontrareis todos los metodos disponibles, y en la carpeta Source\clases, podeis consultar el código fuente y ver como funcina internamente.

Siguiendo con un proceso normal de altas y modificaciones de ficheros, el siguiente paso seria determinar si queremos añadir un registro, o editar el registro actual.

Si quermos hacer una alta, invocaremos el metodo Blank, que nos dejara el buffer de edición vacio y listo para ñadir un nuevo registro.

Por el contrario si queremos editar el registro actual, invocaremos el metodo Load, que cargara el contenido de los campos de la tabla, en el buffer de edición.

Acto seguido ya podemos visualizar, editar y modificar el contenido de los campos de nuestro objeto, y la forma de referirnos a los campos es nombre de nuestro objeto : nombre del campo.

@ 10,10 GET oDbf:Codigo

@ 12,10 GET oDbf:Nombre ....

cuando hayamos introducido todos nuestros datos, si queremos guardarlos actuaremos de la siguiente manera.

Comprobaremos si realmente se han modificado los datos, y para ello consultamos el valor de oDbf:Modified(), si nos devuelve verdadero, es que hay cambios.

Si el registro es una alta, en este momento crearemos el registro (hasta ahora hemos estado trabajando sobre un buffer temporal en memoria).

oDbf:Append()

y tanto si es una alta como una edición de un registro existente, grabaremos el contenido del buffer temporal a los campos de la tabla.

oDbf:Save()

Sencillo y potente, verdad?. Bueno pues ADO, funciona de una manera muy parecida, cambian los nombres de algunos metodos, pero en el fondo la filosofia de funcionamiento es la misma.

Aqui teneis algunos metodos con la misma funcionalidad tanto en tDatabase como en ADO

Código fuente ejemplo mantenimiento ficha de proveedores usando tDatabase: STATIC FUNCTION EdtPro(lAdd)    LOCAL oDlg,oDbf,lSave:=.F.    DEFAULT lAdd:=.F.    Select Proveedores    DATABASE oDbf    DEFINE DIALOG oDlg RESOURCE "MANPROVE"    IF lAdd       oDbf:Blank()    ELSE       oDbf:Load()    ENDIF    oDlg:SetText('('+ProcName()+')'+IF(lAdd,' Añadir Proveedores',' Editar ficha proveedor'))    REDEFINE GET oDbf:Codprov   ID 601 OF oDlg VALID {|oGet|Ajusta(oGet)} WHEN lAdd    REDEFINE GET oDbf:Nombre    ID 602 OF oDlg    REDEFINE GET oDbf:Nif       ID 603 OF oDlg    REDEFINE GET oDbf:Dir1      ID 604 OF oDlg    REDEFINE GET oDbf:Dir2      ID 605 OF oDlg    REDEFINE GET oDbf:Cp        ID 606 OF oDlg    REDEFINE GET oDbf:Provincia ID 607 OF oDlg    REDEFINE GET oDbf:Tel1      ID 608 OF oDlg    REDEFINE GET oDbf:Tel2      ID 609 OF oDlg    REDEFINE GET oDbf:Movil     ID 610 OF oDlg    REDEFINE GET oDbf:Fax       ID 611 OF oDlg    REDEFINE GET oDbf:Percon    ID 612 OF oDlg    REDEFINE BUTTON ID 1 OF oDlg ACTION (oDlg:End(), lSave := .T.) // OK    REDEFINE BUTTON ID 2 OF oDlg ACTION (oDlg:End()) // Cancel    ACTIVATE DIALOG oDlg CENTERED    IF lSave .AND. oDbf:Modified()       IF lAdd          oDbf:Append()       ENDIF       oDbf:Save()    ENDIF RETURN NIL _________________ Saludos desde Mallorca Biel Gabriel Maimó

ADO ConnectionString

Al usar ADO, el primer escollo con el que nos vamos a encontrar, es el ConnectionString. Es la
cadena que tenemos que pasarle como parametro al objeto connection, para que se conecte con nuestro servidor de base de datos. Si fallamos en este paso, es imposible que nada nos funcione, por eso es un parametro muy importante, y que debemos especificar correctamente. A tal efecto disponemos de una web en la cual podemos encontrar las cadenas de conexión de la mayoira de servidores http://www.connectionstrings.com/ Pero tambien diposnemos de otro medio más sencillo y practico con un pequeño programa desarrollado por nosotros mismos, y explotando automatizacion ole y el componente DataLinks. La gran ventaja es que podreis probar al momento si la conexión con el servidor se realiza correctamente.

Aqui teneis el codiggo fuente, como veis son cuatro linea.

#include "FiveWin.Ch"
FUNCTION main()

LOCAL oDataLink := TOleAuto():New("Datalinks"),;

oConn := oDataLink:PromptNew(),;

cConn:=''

cConn:=oConn:ConnectionString
?cConnRETURN
RETURN NIL

FUNCTION RddSys(); RETURN NIL

Al ejecutar nos aparece la siguiente pantalla

.

Como podeis ver tenemos cuatro pestañas, en la primera nos aparecen todos los
controladores OLE DB que tenemos instalados en nuestro sistema.

En la segunda, nos permite seleccionar un acceso a datos via ODBC,
previamente debe de haberse definido el origen de datos en panel de
control, herramientas administrativas.

La pestaña dos varia si elejimos el acceso via OLE DB, presentara el siguiente
aspecto.

En esta pantalla debemos especificar, el origen de datos, ubicacion, usuario y contraseña, si procede.

Ademas en esta pantalla, disponemos de un boton que nos permite probar la conexion. Si la prueba de conexion es correcta, nos devuelve una ventana con un mensaje de confirmación.

Disponemos de dos pestañas adicionales, donde pueden definirse otros parametros, y en la última pestaña donde nos visualiza todos los parametros definidos para la conexón.

Si pulsamos aceptar, nos aparecera otra ventan visualizando el contenido de la variable cConn,
que es el string que debemos pasar al objeto connection. De esta manera podras definir un connectionString, con todos los parametros necesarios, para el origen de datos que quieras, sin preocuparte por la sintaxis.

Bueno, como siempre espero que os sea de utilidad, y que sigais leyendo el blog de vez en cuando. Un saludo desde Mallorca.

CONEXION A ORIGENES DE DATOS SQL

Al comentzar a escribir este blog, me han llegado sugerencias de que escriba sobre el tema ADO, SQL, etc, pues parece es algo que cada dia interesa más a la comunidad xBase.

En este primera entrada referente al tema SQL, comentare brevente tres de las opciones que disponemos los usuarios xBase(FiveWin) para conectarlos a bases de datos SQL.

1. ODBC (Open Data Base Conectivity). Es el sistema más antiguo con el que contamos, y actualmente en el foro cuenta con algo de mala fama.
   Personalmente lo he utilizado, y he conseguido muy buenos resultados. Toda la funcionalidad esta descrita en dos clases de fiveWin, de las cuales disponeis del código fuente. Eso permite el control absoluto del funcionamiento, y ademas la adecuación en caso de necesidad. Una pega en cuanto a seguridad, es que trabaja con ficheros temporales DBF que los crea al vuelo, y carga con los datos obtenidos del servidor. Para conectarnos al servidor de bases de datos, debemos crear un origen de datos ODBC(DSN de sistema normalmente), puede ser creado por programa, aunque no es algo trivial. Algunos instaladores tambien permiten crear origenes de datos ODBC.


2. ADO (ActiveX Data Objects), posiblemente este sea el metodo mas potente del que disponemos para atacar a motores de bases de datos, aunque tambien el que va a requerir más conocimientos. En la red podremos encontrar infinidad de documentacion, sobre los objetos ado, sus metodos, propiedades, etc. Para conectarlos al servidor, tenemos que definir una cadena de conexión dentro de nuestro programa, no es necesario definir nada externo a nuestro programa. Para conexion con ADO necesitamos que el motor de base de datos soporte OLE DB, aunque si no lo soporta, simpre podemos acceder mediante un origen de datos ODBC ya definido.


3. AdoRdd,se trata de manejar conexiones via ADO, pero con comandos xBase. Es la última opción que ha aparecido, y es sin duda la mas sencilla de implentar y casi no requiere conocimiento alguno de ADO. De haber existido antes, seguramente es la que hubiera escojido para mis proyectos. Quizas no se llegue al control o rendimiento que se pueda
   alcanzar utilizando ADO directamente, pero el coste de implementación y aprencizaje, es mucisimo menor.

Con cualquiera de las tres opciones, es casi indispensaple unos conocimientos minimos del lenguaje de consulta de datos SQL, y del funcionamiento y diseño de las bases de datos relacionales. Cuanto mas conozcas SQL, mucho mejor.

Usando List & Label 12

Recientemente en el foro de FiveWin se viene hablando del generador de informes List & Label. Y aunque se comenta que es muy bueno, que funciona muy bioen, etc, la verdad es que no hay hasta la fecha ningún ejemplo funcional para ser usado con FiveWin. Bueno realmente si hay una primera aproximación de Jairo Centeno (gracias), que expone un ejemplo de como usar el generador de informes.

En esta entrada intentare poner un ejemplo de como usar el diseñador, y otro de lanzar un informe.

El primer punto a destacar es la filosofía de uso de este generador de informes. Mientras que la mayoria de generadores se basan en la conexion a un origen de datos, LL recibe los datos al momento, y su origen puede ser cualquiera, dejando en manos del programador el envio de datos al reporte.

La función DefineData, es la encargada de pasar los datos al reporte, tanto para diseño como para impresión. El primer paso es convertir los datos xBase a formato LL, y el segundo definir el campo o la variable dependiendo del valor recibido como parametro en lAsField. El segundo parametro oLl, es un objeto valido LL ya creado.

Para lanzar el diseñador de informes, llamamos a la funcion Disenya los pasos a seguir son muy simples.
1.- Creamos un nuevo objeto LL oLl = TActiveX():New( oWnd, "L12.List-Label12_Ctrl_32.1" )
2.- Ajustamos varias propiedades del objeto LL
3.- Llamamos a la función DefineData, que le enviara los campos al diseñador de informes.
alias->( DefineData(.t., oLl) )
4.-Invocamos el diseñador
oLl:Do("LlDefineLayout",oWnd:hWnd,"Designer",LL_PROJECT_LIST, "informe.lst")
Facil y sencillo, ahora manipulamos y diseñamos nuestro informe, y lo guardamos. Ya tenemos listo un informe para ser llamado desde nuestra aplicación.

Ya tenemos un informe creado, ahora vamos a llamar el informe desde nuestro programa, podeis revisar el código de la función Imprime que teneis más abjo, el funcionamiento es el siguiente:
1.- Creamos un nuevo objeto LL oLl = TActiveX():New( oWnd, "L12.List-Label12_Ctrl_32.1" )
2.- Ajustamos varias propiedades del objeto LL (inicio de variables, de campos, immpresora por defecto, ...)
3.- Llamamos a la función DefineData, que le enviara los campos al diseñador de informes.

Hasta aqui igual que para el diseñador.

4.- Empezamos la impresión

oLl:Do("LlPrintStart",LL_PROJECT_LIST,"Informe.lst",LL_PRINT_PREVIEW)
oLl:DO("llPrint")
5.- Montamos un bucle que recorra los registros que queremos imprimir, y para cada registro llamamos la Funcion DefineData (convierte y envia los datos aLL) y oLl:DO("llPrintFields") que imprime los campos.

5.- Una vez que hemos terminado los registros que queriamos imprimir, solo nos queda indicarle a LL que ya esta finalizado el listado.
oll:DO("llPrintEnd",0)
oLl:DO("LlPreviewDisplay", "informe.lst", , oWnd:hWnd)


Esto es un ejemplo muy sencillo, pero espero os aclare un poco el modo de funcionar, para ver con más profundidad todas las funciones y parametros, revisad la ayuda del producto.
En el código fuente incluido, se utiliza una tabla cuyo alias es tmp, y se presupone abierta, y una ventana oWnd tambien se presupone definida, y con scope en las funciones.
En la transformacion de tipos de datos, el formato fecha lo convierto a texto, aunque podria convertirse tambien a formato juliano si quisieramos hacer algún tipo de operación con la fecha dentro del informe.
Nada más, esta es mi primera entrada en el blog, así que espero os guste y os sea de utilidad. En la medida del tiempo disponible ire añadiendo nuevas entradas.

Código: #include "cmbtll12.ch" FUNCTION Disenya()    LOCAL oLL,oWnd,hJob,cName:='qsl'    oLl = TActiveX():New( oWnd, "L12.List-Label12_Ctrl_32.1" )    oLl:Do( "LlSetOption", LL_OPTION_MULTIPLETABLELINES, 1)    //Permite multiples tablas    oLl:Do( "LlDefineFieldStart" ) //Limpia buffer de campos    oLl:DO( "LlDefineVariableStart")//Limpia buffer de variablesx    Tmp->( DefineData(.t., oLl) )    oLl:Do("LlSetPrinterDefaultsDir",hJob,"C:\Windows\Temp") //Arranca diseñador    oLl:Do("LlDefineLayout",oWnd:hWnd,"Designer",LL_PROJECT_LIST, "log.lst") RETURN NIL //------------------------------------ FUNCTION Imprime()    LOCAL oLL,oWnd,hJob,cName:='log.lst',cDir:=oAppl:cDirLocal    oLl = TActiveX():New( oAppl:oWnd, "L12.List-Label12_Ctrl_32.1" )    oLl:Do( "LlSetOption", LL_OPTION_MULTIPLETABLELINES, 1)    oLl:Do( "LlDefineFieldStart" )    oLl:DO( "LlDefineVariableStart")    Tmp->( DefineData(.t., oLl) )    oLl:Do("LlSetPrinterDefaultsDir",cDir)    oLl:Do("LlPrintStart",LL_PROJECT_LIST,cName,LL_PRINT_PREVIEW)    oll:DO("llPrintOptionsDialog",oAppl:oWnd:hWnd)    oLl:DO("llPrint")    Tmp->(DBGoTop())    DO WHILE !Tmp->(Eof())       Tmp->(DefineData(.T.,oLl))       oLl:DO("llPrintFields")       Tmp->(DBSkip())    ENDDO    oll:DO("llPrintEnd",0)    oLl:DO("LlPreviewDisplay", cName, , oAppl:oWnd:hWnd)    oLl:DO("llPreviewDeleteFiles",cName,cDir) RETURN NIL //---------------------------------------------- FUNCTION DefineData(lAsField,oLl)    LOCAL FldType, FldContent, lExpr,i,DateBuffer:=Replicate(Chr(0),255)    //Convierte formato xBase a List & Label    FOR i:=1 TO FCount()       DO CASE       CASE FieldType(i)=='N'          FldType:=LL_NUMERIC          FldContent:=Str(FieldGet(i))       CASE FieldType(i)=='C'          FldType:=LL_TEXT          FldContent:=Trim(FieldGet(i))       CASE fieldType(i)=='M'          FldType:=LL_TEXT          FldContent:=FieldGet(i)       CASE FieldType(i)=='L'          FldType:=LL_BOOLEAN          FldContent:=IF(FieldGet(i),'TRUE','FALSE')       CASE FieldType(i)=='D'          FldType:=LL_TEXT          FldContent:=DToC(FieldGet(i))       ENDCASE       IF lAsField          oLl:Do("LlDefineFieldExt",FieldName(i), FldContent, FldType )       ELSE          oLl:Do("LlDefineVariableExt", FieldName(i), FldContent, FldType )       ENDIF    NEXT RETURN NIL