dBFast - Chile

¿Quién es el Alias?

2011-10-17T12:27:00.001-03:00

Para todos quienes programamos en algún lenguaje xBase, sin duda son indispensables las cláusulas SELECT a la hora de cambiarnos de área de trabajo al manipular varios archivos (o tablas) de datos. Es así como cada archivo que utilizamos en una aplicación tiene su SELECT o área de trabajo asignada y que utilizaremos cuando debemos realizar alguna operación sobre la tabla (APPEND BLANK, REPLACE, LIST, DELETE, etc.).

Sin embargo, y en especial ahora que estoy abordando el tema de la migración hacia Harbour Minigui, quiero compartir este excelente artículo de René Flores, creador de "Objeto Persistente", al cual he dedicado un enlace en dBFast Chile desde que inicié este Blog.

René es un antiguo desarrollador de Clipper en Mexico, y a través de su empresa CiberTec, se ha especializado en la consultoría, enseñanza y desarrollo de aplicaciones con Fivewin, Harbour, xHarbour y otras tecnologías xBase, centrándose en la actualidad en Xailer.

El artículo titulado "¿Quién es al Alias?" rompe algunos mitos y paradigmas con respecto al uso de los SELECT en la administración de áreas de trabajo y nos entrega una nueva visión que sin duda nos ayudará a optimizar el uso de tablas de datos en nuestras aplicaciones, y aunque no le he pedido permiso a René para transcribir el artículo en este Blog, estoy seguro de que no se molestará.

Acá les dejo la transcripción,:

Tengo 20 años programando en Clipper, y mas o menos 15 dando clases de programación y análisis y diseño de sistemas, de los cuales 5 estuve dando clases en la Universidad La Salle de México, como catedrático de la Escuela de Ingeniería en la carrera de Ingeniería en Cibernética y Ciencias de la Computación.

He dirigido algunos trabajos de tesis sobre bases de datos, 2 de ellos específicamente sobre lenguajes Xbase y hasta una tesis sobre programación orientada al Objeto con FiveWin, sí sí, aunque ustedes no lo crean FiveWin fue en su momento (hace como 8 años) el tema de un trabajo de titulación profesional de 2 de mis alumnos.

El caso es que en todos estos años pegándole a la tecla con Clipper y ahora con (x)Harbour, me he encontrado con que casi nadie saber manejar los archivos DBF en condiciones.

Actualmente la idea es ir mas por el tema del SQL, pero hay muchas personas que todavía manejan archivos DBF y que conociendo un poco mas sobre ellos se pueden hacer cosas muy interesantes.

Pero vamos a ver..... ¿ como que nadie sabe usar los DBFs ?, si cientos de programadores del mundo los han usado durante años..... de acuerdo, pero de todos esos cientos de programadores, que levanten la mano aquellos que consideren que saben manejar los DBF BIEN.

Si levantaste la mano, continúa leyendo, espero poder enseñarte algo nuevo, si no la levantaste, también continúa leyendo, seguro vas a aprender algo nuevo.

El mito de las 256 "áreas" de trabajo.

Los que venimos del dBase III recordamos que en los libros ponían, dBase puede abrir hasta 256 "areas" de trabajo, entendiendo por "areas de trabjo" un espacio de memoria en donde se "abría" la tabla DBF (está mal llamarla "base de datos"), lo que en el SQL moderno de hoy se llama "cursor".

Estas "areas" estaban numeradas, de tal forma que cuando queríamos abrir una tabla, todos hacíamos (y algunos siguen haciendo) la forma erronea de abrir la tabla:

SELECT 1 // para seleccionar el "area" donde vamos a abrir la tabla
USE archivo.dbf

Esto quería decir que la tabla ARCHIVO.DBF estaría abierta en el "área" 1, así pues siempre que quisiéramos hacer referencia a los campos o a alguna operación sobre ARCHIVO.DBF, antes que nada tendríamos que hacer primeramente un salto al "área" donde está abierta dicha tabla, algo como esto:

SELECT 1
GO TOP
DO WHILE ! EOF()
? Recno()
SKIP
ENDDO

La cosa comienza a ponerse interesante cuando requieres usar mas tablas simultáneamente, digamos unas 5 tablas, entonces erroneamente haces:

SELECT 1
USE archivo1.dbf
SELECT 2
USE archivo2.dbf
......
SELECT 5
USE archivo5.dbf

Mal, mal, mal, esto te lleva a hacer lo que yo he llamado "código ping-pong", es decir selección de área, operación, selección de otra área, otra operación, selección de otra area mas, otra operación mas, y luego vamos de vuelta al área original, lo cual nos lleva a un código lleno de SELECTs por todos sitios, que es complicado de mantener.

Si a esto aunamos que a 16 bits el número de áreas de trabajo estaba limitado por la memoria (las 256 áreas de trabajo que prometía dBase nunca fueron ciertas), entonces nuestro código se volvía un maremagnum de saltos entre áreas, de tener que cerrar tablas para abrir otras en las mismas "áreas" de tener que acordarte en que número de área quedaba tal o cual tabla DBF de tal o cual proceso, vamos, un rollo.

Y todo por no utilizar el "alias" de los archivos DBF.

¿ Y quien o qué es ALIAS ?

En todos los lenguajes de programación no orientados a datos, como Pascal, "C" o el mismo Basic, cuando se manejan archivos de datos, siempre se les asignan 2 nombres, el nombre "físico" que es el nombre del archivo tal cual se almacena en el disco, y el nombre "lógico", que es el nombre con el cual haremos referencia dentro del código de nuestro programa.

Clipper/(x)Harbour no es una excepción a esta regla, porque en realidad, SIEMPRE estas manejando 2 nombres cuando abres una tabla DBF para trabajar sobre ella, es decir, cuando haces algo como esto :

USE archivo.dbf

En realidad estas generando un "ALIAS", es decir, un "apodo" para hacer referencia al archivo abierto durante la ejecución de tu programa.

Si revisas la sintaxis del comando USE, te encontrarás varias cosas interesantes:

USE [ ;
[INDEX ] ;
[ALIAS ] ;
[EXCLUSIVE | SHARED] ;
[NEW] ;
[READONLY] ;
[VIA ]

El comando USE tiene una clausula ALIAS, que si no fuera importante, creeme, no la pondrían como parte de la sintaxis.

Esta clausula ALIAS se utiliza para darle un "nombre lógico" a tu tabla para que puedas manejarla en memoria, si tu omites este nombre, se asigna automáticamente como "alias" el mismo nombre de la tabla, sin extensión.

El ALIAS de una tabla es una pieza muy importante de la programación de datos porque si sabes como utilizarlo, te ahorrarás lineas y líneas de SELECTS inútiles.

Existe un "operador ALIAS", representado por un "->" signo de menos + signo de mayor que, este operador nos servirá para hacer referencia al área de trabajo que deseamos usar sin necesidad de tener que hacer un SELECT

Por ejemplo:

USE archivo1.dbf
archivo1->(dbgotop())
DO WHILE ! archivo1->(EOF())
? archivo1->(RECNO())
archivo1->(DBSKIP())
ENDDO

En este ejemplo asumimos que no hemos usado la cáusula ALIAS, luego entonces el ALIAS asignado por omisión será "archivo1" (sin extensión), luego usaremos el operador "alias" (->) para indicar que operaciones deben realizarse sobre él.

Nota por favor que todas las operaciones sobre la tabla son funciones NO COMANDOS y que todas las operaciones van encerradas entre paréntesis.

Otra cláusula importante del comando USE es la claúsula NEW, esta clausula te ahorrará miles de lineas de SELECTS ya que esta clausula abre la tabla DBF en la primer área que se encuentre disponible, es decir, no tienes que hacer un SELECT previo a abrir un DBF, simplemente le pones NEW al momento de abrir, y dejas que Clipper/(x)Harbour se haga cargo del resto.

USE archivo1.dbf NEW
USE archivo2.dbf NEW

No tienes que hacer ningun SELECT para abrir las tablas, ahora, para hacer referencia a los campos de cada archivos, o bien realizar operaciones sobre las tablas, tampoco hay necesidad de hacer SELECT, el ALIAS nos soluciona la vida:

USE archivo1.dbf NEW
USE archivo2.dbf NEW

archivo1->(DBGOTOP())
archivo2->(DBGOBOTTOM())

DO WHILE ! archivo2->(BOF())
? archivo2->(fieldget(1))
? archivo1->(fieldget(5))
IF ! archivo1->(EOF())
archivo1->(DBSKIP())
ENDIF
archivo2->(DBSKIP(-1))
ENDDO

El manejo de los campos es muy simple, funciona igual, basta con que pongas el nombre del campo despues del operador alias SIN PARENTESIS:

? archivo1->nombre
? archivo2->iva

Los campos también son asignables usando el operador alias, tanto para leer sus valores, como para actualizar o agregar valores, sustituyendo con esto al comando REPLACE:

cNombre := archivo1->nombre
archivo2->(DBAPPEND()) // el comando APPEND BLANK se sustituye pro su función
archivo2->nombre := cNombre // no hay REPLACE, el valor se asinga directamente

Esto de los alias puede ser tan complejo como quieras, un ejemplo típico es buscar en una segunda tabla el valor de un campo contenido en la primera:

CON SELECTS:

SELECT 1
cNombre := field->nombre
SELECT 2
SEEK cNombre

CON ALIAS:

archivo2->(DBSEEK(archivo1->nombre))

Efectivamente, con la línea anterior, basta con que hagas referencia a los alias y en vez de usar 4 líneas de código en una sola solucionas el problema y haces exactamente lo mismo.

Ahora esto del alias es mas versátil porque tu puedes dar TU PROPIO ALIAS

USE archivo1.dbf ALIAS MiAlias NEW
MiAlias->(DBGOTOP())
? MiAlias->nombre

Usando tu propio ALIAS puedes darle un nombre mas identificativo al manejo de tus tablas DBFs.

Veamos otro ejemplo mas complejo pero sin duda mucho mas útil:

USE archivo.dbf ALIAS ArchPant SHARED NEW
USE archivo.dbf ALIAS ArchRep SHARED NEW
USE archivo.dbf ALIAS ArchMovs SHARED NEW

NO, No hay ningún error, estoy abriendo LA MISMA TABLA (archivo.dbf) 3 veces AL MISMO TIEMPO..... ¿ que no causa esto un error del tipo ALIAS already in use ?.... pues va a ser que no.... y esto es algo de lo mas alucinante y útil de los archivos DBFs.

Una de las cosas que casi nadie usa es esta poderosa característica de los DBFs, poder abrir la misma tabla 2, 3, 4, o "n" veces al mismo tiempo, esto se logra CAMBIANDO EL ALIAS y abriendo la tabla como compartida (SHARED) como si fuesemos a programar para red.

Lo interesante de esta forma de usar los DBFs es que cada "alias" mantiene su puntero independiente, es decir puedes hacer algo tan loco como esto:

ArchPant->(DBGOTOP())
ArchMovs->(DBGOTO(5))
ArchRep->(DBGOBOTTOM())

El puntero de cada "alias" se moverá a distintas posiciones, sin importar que estemos hablando del mismo archivo DBF (recuerda, una cosa es el nombre físico y otra es el nombre lógico) Y si tu preguntas los valores de los campos :

ArchPant->nombre
ArchMovs->nombre
ArchRep->nombre

Seguramente obtendrás valores distintos en cada oportunidad, esto porque sin importar que sea el mismo archivo, para efectos prácticos en la memoria de la computadora esta "abierto" 3 veces bajo 3 alias distintos y cada alias guarda y mantiene su propio estado. Solo como comentario, Xailer a través de los DataSets facilita aun mas el manejo de los alias.

Pero volviendo al tema, para los que no tienen Xailer o tienen la versión personal, aun así podemos seguir haciendo cosas interesantes a base de usar solo los alias:

Si yo hago:

ArchMovs->(DbAppend())
ArchMovs->nombre := "Juan Perez"
ArchMovs->direccion := "Da igual donde viva, Viva El "
ArchMovs->(DBCommit())
ArchMovs->(DBUnlock())

El registro añadido será visible EN TODOS LOS ALIAS QUE APUNTEN AL MISMO ARCHIVO
FISICO, esto es maravilloso, porque es como dar de alta al mismo tiempo en 3 tablas distintas.

La pregunta que puede surgir en este momento es .... ¿ y esto como para que me serviría en la vida real ?.... pues para facilitarte la existencia:

Supongamos que tu quieres mostrar en pantalla un browse del archivo de clientes, donde tienes además 2 índices, uno por clave y otro por nombre, y que además quieres hacer operaciones de mantenimiento como altas bajas y cambios y para rematar quieres hacer reportes que pueden ir ordenados por clave o por nombre, entonces haríamos algo como esto:

USE clientes ALIAS CliBrow SHARED NEW
CliBrow->(OrdSetFocus("nombre")) // arrancamos ordenado por nombre del cliente
CliBrow->(DBGOTOP())

USE clientes ALIAS CliMovs SHARED NEW
CliMovs->(OrdSetFocus("clave")) // esta segunda instacia del archivo va ordenado por clave

USE clientes ALIAS CliReps SHARED NEW
CliRep->(OrdSetFocus("clave") // idem anterior.

Si yo quiero meter la primer instancia del archivo de clientes a un browse, basta con hacer:

CliBrow->(Browse())

¡¡¡Así de simple !!!!! El usuario podrá moverse sobre el browse y podrá cambiar los criterios de ordenación sin afectar a los otros 2 alias que apuntan a la misma tabla.

Ahora viene lo bueno, si yo quiero hacer un reporte o hacer un ABM sobre la tabla clientes NO LO HAGO SOBRE EL ALIAS DEL BROWSE, lo hago ya sea sobre el alias CliMovs o sobre el alias CliReps para no molestar al alias del browse.

Cuando trabajas con un solo alias, y quieres dar un mantenimiento a una tabla mostrada en un browse, entonces tienes que "guardar" el estado del área de trabajo que muestras en el browse, es decir, en que registro estás, sobre que indice estas trabajando, etc. y luego hacer las operaciones de mantenimiento sobre ese mismo alias que pueden vincular, mover el puntero sobre la tabla, agregar un registro nuevo, cambiar el orden del índice actual, realizar búsquedas, etc, y luego de la operación, debes regresar todo a como estaba antes. Esta técnica te evita eso precisamente.

Por ejemplo, si tu quieres agregar un registro el código sería algo como esto:

CliMovs->(RLOCK())
CliMovs->(DBGOBOTTOM())
nSiguienteClave := CliMovs->clave+1
CliMovs->(DbAppend())
CliMovs->clave := nSiguienteClave
CliMovs->nombre:= cVariableConElNuevoNombre
CliMovs->(DbCommit())
CliMovs->(DBUnlock())

Nota que toda la operación de mantenimiento la hacemos sobre el Alias CliMovs, no sobre el Alias CliBrow, de esta manera no tenemos que guardar posiciones ni estados, porque CliBrow no se va a mover su puntero y su índice se quedan como están, en cambio CliMovs hará toda la labor de mantenimiento y el cambio se verá reflejado automáticamente en CliBrow y en CliRep en cuanto haya terminado la actualización CliMovs, el Browse ni si quiera se va a mover, a menos claro, que la operación de mantenimiento afecte al registro en el cual estaba el puntero del alias CliBrow.

Lo mismo pasa para los reportes, si yo quiero un reporte, usualmente ese reporte abarca un rango de datos, para no molestar al Browse ni a su alias, pues el reporte lo emitimos sobre el alias CliRep:

CliRep->(OrdSetFocus("nombre"))
CliRep->(OrdScope(0,"A")) // reporte de todos los clientes cuyo nombre empiece con "A"
CliRep->(OrdScope(1,"A"))
CliRep->(DBGOTOP())
DO WHILE ! CliRep->(EOF())
... aqui val el codigo del reporte...
CliRep->(DBSKIP())
ENDDO

Y el CliBrow ni se va a enterar que hay un alias llamado CliRep con un Scope sobre la tabla moviendo el puntero para generar un informe.

Esta técnica de programación es ideal para Windows, sobre todo si estás trabajando en entornos MDI porque puedes asignar a cada ventana hija los alias que vaya a necesitar para trabajar, en los entornos MDI una de las cosas mas complicadas de manejar es precisamente esa, evitar que el puntero en la ventana "A" se mueva cuando en la ventana "B" se está realizando otra operación sobre la misma tabla DBF.

Puedes incluso abrir todas las tablas al momento de arrancar tu programa, porque en (x)Harbour no existe la limitación de las 256 "areas" de dBase, en (x)Harbour prácticamente no hay limite en la cantidad de archivos que puedas abrir simultáneamente.

En Xailer Pro y Enterprise no tienes los problemas de Alias cuando trabajas en entornos MDI porque Xailer te provee de los DataSets que usualmente ya van "atados" a cada formulario y como expliqué antes, te ahorran el tema de tener que lidiar con alias, en FiveWin o en la versión Personal de Xailer, el uso de esta técnica es indispensable para trabajar con entornos MDI, en (x)Harbour modo consola, esta ténica te puede ayudar a eliminar muchos vicios de programación y a ahorrar muchas líneas de código.

Cabe señalar que esto mismo es aplicable a Advantage DataBase Server, de hecho el manual de ADS recomienda que todas las tablas estén abiertas desde que arranca la aplicación, esto es aplicable tanto a archivos DBF con NTX o CDX o bien a tablas ADT con índices ADI.

En un próximo artículo discutiremos otra técnica relacionada con esta llamada "alias dinámicos" que hará que no tengas que preocuparte prácticamente por nada que tenga que ver con el acomodo de las tablas en memoria.

___________________________________________________________________________________

Espero les haya gustado y les sirva para replantear el diseño de sus aplicaciones a la hora de utilizar sus tablas DBF.

Les dejo el enlace al artículo original de René Flores en Objeto persistente: http://objetopersistente.blogspot.com/2008/02/quien-es-alias.html

Saludos,

Migrando desde dBFast a Harbour Minigui

2011-09-19T18:58:00.001-03:00

Como ya hemos visto en artículos anteriores, nuestro fiel dBFast, que ha sobrevivido por alrededor de 20 años prácticamente sin cambios, desde Windows 3.1 a Windows 7, no logrará sobrevivir a la nueva generación de tecnologías basadas en 64 bits que, en forma lenta pero constante, se han ido consolidando en el mercado tanto de la informática personal como en la informática de negocios. Ante esta disyuntiva, nos hemos visto obligados a buscar un nuevo lenguaje de programación que nos permita desarrollar aplicaciones o migrar las que ya tenemos con una curva mínima de aprendizaje, y con la menor cantidad de cambios posibles. ¿Será pedir mucho?

En mi opinión, y según lo manifiesto en el artículo que escribí el 4 de mayo de 2011 (Ver artículo), la herramienta que reúne las condiciones mencionadas en el párrafo anterior es Harbour Minigui. Como dije en ese artículo, Harbour es un compilador Open Source, 100% compatible con Clipper. Minigui en tanto, es una librería desarrollada en xHarbour y C nativo por Roberto López (Argentina) que proporciona una interfaz gráfica a los programas escritos en (x)Harbour. Minigui además proporciona un IDE que facilita el desarrollo de aplicaciones y la organización de nuestros proyectos (Sitio Oficial de Harbour Minigui).

Similitudes entre dBFast y Harbour Minigui

Afortunadamente, y aunque cueste creerlo, hay bastantes similitudes entre dBFast y Harbour Minigui. Esto gracias a que Harbour = Clipper (100% compatibles), y Clipper es descendiente directo de dBase al igual que dBFast, por lo cual existe un gran porcentaje de compatibilidad entre las sintaxis de los dos lenguajes. No debemos olvidar que tanto Clipper como dBFast son concebidos en sus inicios como compiladores para dBase. Ambos lenguajes mantienen los comandos básicos para la apertura y administración de tablas, los comandos de red, tratamiento de variables y tipos de datos, estructuras de control, etc.; de modo que los cambios que veremos serán más bien de forma que de fondo.

De acuerdo a lo anterior, la principal dificultad que deberemos sortear al migrar desde dBFast a Harbour Minigui, está en la forma de programar.

En dBFast los programas tienen invariablemente la misma estructura, esto es:

Comenzamos con las sentencias del preprocesador #define e #include,
Establecemos los parámetros de funcionamiento mediante el uso de los comandos SET
Abrimos las tablas de datos
Definimos Constantes y Variables
Creamos Ventanas y Controles (incluidos los comandos SAY y GET)
Creamos el ciclo dentro del cual se ejecutará el programa (DO WHILE - ENDDO) dentro del cual...
Chequeamos los eventos, en qué control se producen y dependiendo de eso, llamamos los programas y/o funciones que deben ejecutarse,
Cerramos las tablas de datos.

Veamos el siguiente ejemplo:

******************************************
* Programa: Ej_01.prg
******************************************
#DEFINE bOk "Aceptar"
#DEFINE bCancel "Cancelar"

SET DATE FRENCH
SET DELETED ON
SET CONFIRM ON

USE Personas.dbf

cNombre = SPACE(30)
nEdad = 0

CREATE WINDOW "Personas" FROM 10,10 TO 20,50

@01,02 SAY "Nombre:" GET cNombre PICTURE "@!" VALID .NOT. EMPTY(cName)
@03,02 SAY "Edad:" GET nEdad PICTURE "99"
CREATE BUTTON bOk AT 5,15 SIZE 1,10
CREATE BUTTON bCancel AT 5 30 SIZE 1,10

SET EXIT BUTTON TO bCancel

DO WHILE .T.
READ SAVE MODAL
nEvent = EVENT()
DO CASE
CASE nEvent = 1
IF LASTKEY() = 27
EXIT
ENDIF
CASE nEvent = 1
IF BUTTON() = bOk
APPEND BLANK
REPLACE NOMBPERS WITH cNombre
REPLACE EDADPERS WITH nEdad
COMMIT

cNombre = SPACE(20)
nEdad = 0

ELSE
EXIT
ENDIF
ENDCASE

ENDDO

CLOSE WINDOW "Personas"

CLOSE DATABASES

RETURN

******************************************

Si ponemos atención, veremos que a diferencia de la programación para DOS, en que la ventana y los controles debieran estar dentro de un ciclo para redibujar la pantalla cada vez que se requiera, en dBFast estos objetos permanecen invariables durante la ejecución del programa y no necesitan ser redibujados. Por su parte, el ciclo solo evalúa los eventos (clic, doble clic, pulsación de teclas, etc.) y dependiendo del evento y del control en el cual se produce, realizamos una determinada acción a través de una llamada a función o procedimiento.

Por otra parte Harbour Minigui permite definir los objetos (controles en dBFast) en modo estándar o xBase y en modo alternativo. El modo alternativo permite utilizar definiciones similares a la de otros lenguajes visuales como Visual dBase 7.5. Veamos por ejemplo las dos maneras posibles de definir un Botón (Button):

Sintaxis Estándar:

@ <nRow> ,<nCol>

BUTTON <ControlName>

[ OF | PARENT <ParentWindowName> ]

CAPTION <cCaption>

PICTURE <cPictureName> [ TOP | BOTTOM | LEFT | RIGHT ]

ACTION | ONCLICK | ON CLICK <ActionProcedureName> | <bBlock>

[ WIDTH <nWidth> HEIGHT <nHeight> ]

[ FONT <cFontName> SIZE <nFontSize> ]

[ BOLD ] [ ITALIC ] [ UNDERLINE ] [ STRIKEOUT ]

[ TOOLTIP <cToolTipText> ]

[ FLAT ]

[ NOTRANSPARENT ]

[ ON GOTFOCUS <OnGotFocusProcedur> | <bBlock> ]

[ ON LOSTFOCUS <OnLostFocusProcedure> | <bBlock> ]

[ NOTABSTOP ]

[ HELPID <nHelpId> ]

[ INVISIBLE ]

[ MULTILINE ]

Sintaxis alternativa:

DEFINE BUTTON <ButtonName>

PARENT <ParentWindowName>

ROW <nValue>

COL <nValue>

CAPTION <cValue>

PICTURE <cValue>

PICTALIGNMENT Top | Left | Right | Bottom

ONCLICK <ActionProcedure>

WIDTH <nValue>

HEIGHT <nValue>

FONTNAME <cValue>

FONTSIZE <nValue>

FONTBOLD <lValue>

FONTITALIC <lValue>

FONTUNDERLINE <lValue>

FONTSTRIKEOUT <lValue>

TOOLTIP <cValue>

FLAT <lValue>

TRANSPARENT <lValue>

ONGOTFOCUS <ActionProcedure>

ONLOSTFOCUS <ActionProcedure>

TABSTOP <lValue>

HELPID <nValue>

VISIBLE <lValue>

MULTILINE <lValue>

END BUTTON

Veamos el siguiente ejemplo de un programa desarrollado en Harbour Minigui:

************************************

#include "hmg.ch"

Function Main

DEFINE WINDOW Win_1 ;

AT 0,0 ;

WIDTH 400 ;

HEIGHT 300 ;

TITLE 'Tutor 04 TextBox Test' ;

MAIN

DEFINE MAIN MENU

POPUP "First Popup"

ITEM 'Change TextBox Content' ACTION Win_1.Text_1.Value := 'New TextBox Value'

ITEM 'Retrieve TextBox Content' ACTION MsgInfo ( Win_1.Text_1.Value)

SEPARATOR

ITEM 'Change Numeric TextBox Content' ACTION Win_1.Text_2.Value := 100

ITEM 'Retrieve Numeric TextBox Content' ACTION MsgInfo ( Str(Win_1.Text_2.Value))

SEPARATOR

ITEM 'Change Numeric (InputMask) TextBox Content' ACTION Win_1.Text_3.Value := 1234.12

ITEM 'Retrieve Numeric (InputMask) TextBox Content' ACTION MsgInfo ( Str(Win_1.Text_3.Value))

END POPUP

END MENU

@ 40 , 120 TEXTBOX Text_1

@ 80 , 120 TEXTBOX Text_2 NUMERIC

@ 120 , 120 TEXTBOX Text_3 NUMERIC INPUTMASK '9999.99'

END WINDOW

ACTIVATE WINDOW Win_1

Return

************************************

Al ver el programa de ejemplo, algún programador de dBFast no familiarizado con los lenguajes visuales me preguntará ¿y aquí dónde está el ciclo DO WHILE - ENDDO? ¿en qué parte puedo chequear los eventos para llamar a mis funciones o procedimientos?

La verdad es que el programa está completo y no necesitamos ningún ciclo para chequear eventos. Ocurre que lo que para dBFast eran Controles, para Harbour Minigui son Objetos, y los objetos tienen ciertas particularidades. Por ejemplo, si definimos un botón utilizando la sintaxis alternativa (Todos los objetos creados con el IDE se definen utilizando la sintaxis alternativa) veremos que este posee Propiedades, responde a ciertos Eventos específicos, y posee ciertos Métodos equivalentes a "reacciones" que permiten modificar el objeto en cuestión. En el fondo, basta con definir los controles, establecer sus propiedades y asignar una procedure o función a alguno de los eventos que genera el objeto.

Un botón específicamente posee las siguientes propiedades:

- Enabled

- Visible

- Row

- Col

- Width

- Height

- Caption

- FontName

- FontSize

- FontBold

- FontItalic

- FontUnderline

- FontStrikeout

- ToolTip

- Picture

- Name (R)

- Parent (D)

- Flat (D)

- TabStop (D)

- HelpId (D)

- Transparent (D)

- PictAlignment (D)

- MultiLine (D)

D: Disponible solo en tiempo de diseño

R: Reservado, no modificable. Elemento esencial para la definición del objeto

Un botón responde solo a los siguientes eventos:

- OnGotFocus (Cuando obtiene el foco)

- OnLostFocus (Cuando pierde el foco)

- OnClick o Action (Cuando hacemos clic sobre él. Es en este evento en donde asignamos un procedimiento)

Un botón también posee los siguientes métodos (o reacciones)

- Show (Hacer visible el botón, el equivalente en dBFast es SHOW CONTROL)

- Hide (Ocultar el botón, el equivalente en dBFast es HIDE CONTROL)

- SetFocus (Llevar el foco hasta el botón, el equivalente en dBFast es SELECT CONTROL)

- Release (Eliminar el objeto botón, el equivalente en dBFast es CLOSE CONTROL)

Cuando queremos hacer referencia a un deterrminado objeto, por ejemplo el botón del cual hablamos, debemos utilizar la sintaxis de los lenguajes visuales, es decir:

NombreVentana.NombreControl.Método

o bien,

NombreVentana.NombreControl.Propiedad := Valor

Otra cosa importante que debemos tener en cuenta es que si utilizamos objetos para el ingreso de datos como por ejemplo, un control Textbox, no necesitamos una variable para recibir esos datos pues los objetos utilizan una de sus propiedades, por lo general la propiedad Value, para almacenar los datos.

Por ejemplo, si queremos ingresar un nombre en dBFast , primero debemos definir la variable ( cNombre = SPACE(30) ) y luego ingresar el nombre utilizando cualquiera de las formas que se muestran a continuación:

- @01,02 SAY "Nombre:" GET cNombre

- CREATE CONTROL TEXT "Text_Nombre" AT 2,10 SIZE 1,30 SAVE TO cNombre

Si posteriormente queremos guardar el nombre ingresado en el campo NOMPERS de la tabla PERSONAS.DBF, solo debemos hacer referencia a la variable en el comando REPLACE, es decir:

REPLACE NOMPERS WITH cNombre

Para hacer la misma operación con Minigui primero debemos definir el control de la siguiente forma (por cierto, es el IDE el que genera el código):

DEFINE TEXTBOX Text_Nombre
ROW 10
COL 90
WIDTH 300
HEIGHT 24
FONTNAME "Arial"
FONTSIZE 9
TOOLTIP ""
ONCHANGE Nil
ONGOTFOCUS Nil
ONLOSTFOCUS Nil
FONTBOLD .F.
FONTITALIC .F.
FONTUNDERLINE .F.
FONTSTRIKEOUT .F.
ONENTER Nil
HELPID Nil
TABSTOP .T.
VISIBLE .T.
READONLY .F.
RIGHTALIGN .F.
DISABLEDBACKCOLOR Nil
DISABLEDFONTCOLOR Nil
BACKCOLOR NIL
FONTCOLOR NIL
INPUTMASK Nil
FORMAT Nil
VALUE ""
END TEXTBOX

Parece más complicado que en dBFast, pero en el fondo, en la definición del objeto solo se especifican las propiedades y lo que debe hacerse ante cada evento. Esta tarea se facilita enormemente utilizando el Inspector de Objeto incorporado en el IDE de Minigui. Ahora, si queremos almacenar el valor ingresado en el Textbox en el campo NOMPERS de la tabla PERSONAS.DBF, debemos hacer lo siguiente:

REPLACE NOMPERS WITH NombreVentana.Text_Nombre.Value

Se me olvidaba un detalle importante, cuando utilizamos un objeto BROWSE y desplazamos el puntero por los registros del control, la propiedad Value devuelve el número de registro seleccionado en el objeto, pero a diferencia de dBFast, NO mueve el puntero en la tabla. Para actualizar la posición del puntero en la tabla debemos utilizar el comando GO de la siguiente forma:

GO NombreVentana.NombreBrowse.Value

Otra opción es agregar esta instrucción en el evento ONCHANGE del objeto Browse.

A continuación les dejo una pequeña aplicación para administrar un archivo de Personas (Personas.Dbf) con dos tablas de índices, un cuadro de búsqueda incremental y codificación automática. Este ejemplo utiliza una interfaz similar a los ejemplos anteriores desarrollados en dBFast y ha sido desarrollado íntegramente en Harbour Minigui versión 3.0.35. El ejemplo contiene todos los archivos necesarios para ejecutar la aplicación, he tratado de documentar las funciones y he simplificado el código para una mejor comprensión de la lógica de programación.

Capturas del ejemplo:

Descargar el programa de ejemplo desde MEGAUPLOAD:

Enlace de descarga: http://www.megaupload.com/?d=PAMFJ4BD

El ejemplo contiene los siguientes archivos:

Ejemplo_1.hbp (Archivo contenedor de proyecto)

Main.Prg (Módulo o programa principal de la aplicación)

Main.Fmg (Formulario principal de la aplicación)

Add_Record.Fmg (Formulario para agregar/modificar registros)

Personas.Dbf (Tabla para el almacenamiento de personas)

Se incluye también la carpeta "BMP" que contiene una gran cantidad de íconos en formato BMP para utilizarlos en botones y objetos que soporten imágenes.

El proyecto contiene dos formularios: Main (Ventana principal de la aplicación) y Add_Record (Ventana utilizada para agregar y modificar registros). Estos formularios contienen los objetos desde los cuales se hacen las llamadas a las distintas funciones y procedimientos. Todas las funciones y procedimientos asignadas a los distintos eventos de cada objeto están contenidas en el módulo Main.prg, y se detallan a continuación:

Formulario "Main":

Función OpenData() : evento ONINIT del formulario
Función CloseData() : evento ONRELEASE del formulario

Objeto Textbox "Text_Buscar" (Casilla de búsqueda incremental):
Función FindRecord() : evento ONCHANGE del objeto

Objeto RadioGroup "Radio_SetIndex" (Selector de índice activo):
Función SetNewIndex() : evento ONCHANGE del objeto

Objeto Button "B_New" (Botón "Nuevo")
Función AddRecord() : evento ACTION del objeto

Objeto Button "B_Edit" (Botón "Editar")
Función EditRecord() : evento ACTION del objeto

Objeto Button "B_Delete" (Botón "Eliminar")
Función DeleteRecord() : evento ACTION del objeto

Objeto Button "B_Close" (Botón "Cerrar")
Método Release del formulario "Main" (Main.Release) asociado al evento ACTION del objeto.

Formulario Add_Record:

En este formulario, no se han asignado funciones para los eventos de los objetos Textbox que reciben los datos. Solo se han asignado eventos a los botones del formulario.

Objeto Button "B_Save" (Botón "Aceptar")
Función SaveRecord() : evento ACTION del objeto

Objeto Button "B_Cancel" (Botón "Cancelar")
Método Release del formulario "Add_Record" (Add_Record.Release)

Adicionalmente se utilizan las funciones:

SetCtrlState() : Activa/desactiva los controles del formulario "Main" en caso de que la tabla "Personas.dbf" no tenga registros. Esta función es invocada desde las funciones OpenData(), SaveRecord() y DeleteRecord().

GetNewId() : Obtiene el nuevo ID automáticamente a partir del último ID ingresado. Esta función es invocada desde la función AddRecord().

Espero que la información y el ejemplo les sean de utilidad, cualquier consulta pueden hacerla a través de los comentarios del Blog, o bien directamente a mi correo electrónico. Les comento que estoy creando un pequeño tutorial con breves videos en HD que grafican los pasos a seguir en la construcción de aplicaciones con Harbour Minigui.

Saludos,

Rodrigo Dinamarca M.

RPV Printing System: Solucionar error SYSTRAY.OCX no está correctamente registrado

2011-06-13T00:30:00.002-04:00

He recibido un par de consultas de personas que utilizan Windows Vista y Windows 7, que tienen problemas para trabajar con las versiones de RPV Printing System disponibles para descarga en este Blog.

Al abrir el visualizador de informes no hay problemas, pero cuando intentan abrir el servidor de impresión de RPV, el cual es fundamental para administrar la impresión de informes, aparece un mensaje de error indicando que el componente "systray.ocx" no está correctamente registrado.

La solución para este problema es instalar los runtimes de Visual Basic 5, los cuales están disponibles para descarga en la sección "Recursos" del Blog.

Ir a la sección Recursos >>

Programa en dBFast modificado para Harbour + Minigui

2011-05-04T10:47:00.004-03:00

Hace unos días, Ramón Denuc me reenvió un email de Jorge López (más conocido como Mustafa), antiguo desarrollador en dBFast que cansado de las limitaciones impuestas por la falta de soporte a raíz del abandono del proyecto por parte de sus creadores, sumadas a la consiguiente falta de actualizaciones que lo hicieran compatible con las tecnologías de 32 bits, y por la amenaza en ciernes que suponen los sistemas operativos de 64 bits para este viejo y fiel lenguaje, en marzo de 2010 anunció a la comunidad dBFast a través de su foro en "La web del Programador" que abandonaba el desarrollo de aplicaciones en dBFast.

Actualmente Jorge utiliza el compilador Harbour, totalmente compatible con Clipper, más la librería gráfica Minigui.

Jorge revisó un artículo que publiqué en este blog el día 13 de octubre de 2010, titulado: "Uso de solapas para administrar archivos de datos en una interfaz basada en CONTROL BROWSE y PICTURE BUTTONS", y modíficó el código dBFast del ejemplo para adaptarlo a Harbour + Minigui. Para clarificar un poco más la idea, comparto con ustedes texto que Jorge le envió a Ramón:

"Hola Ramon

Como estas ? como sigue dBfast ?

He visto la Web que tiene el compañero RODRIGO DINAMARCA

y tiene un Sample que me gusto mucho de un Tab_Browse con

dos Bases de datos y un Buscador comun y los Botones conjuntos

Me gustaria que le hicieras llegar la version que yo he modificado

para HMG que al estar compilada en C pero siendo Clipper si es

de 32 Bits. que veo que es el tema que esta preocupando a los

usuarios de dBfast.

Tienes que renombrar los ficheros con extension b_ a--> bat si

tiens que compilar y e_ a --> exe que es el ejecutable.

Sin otro particular un abrazo

Jorge"

La verdad es que me impresionó bastante el resultado obtenido por Jorge al compilar su aplicación con Harbour+Minigui.

Este es el ejemplo original desarrollado en dBFast:

Pueden ver el artículo y el ejemplo completo haciendo clic aquí

Este es el ejemplo modificado por Jorge López y compilado con Harbour Minigui:

Como siempre, pueden descargar el ejemplo modificado por Jorge desde Megaupload

Enlace de Descarga: http://www.megaupload.com/?d=MM7PVVGY

Algunos datos interesantes sobre Harbour y Minigui:

Harbour Minigui es un proyecto Open Source (gratuito) iniciado originalmente por Roberto López (Argentina). Minigui es una librería escrita en lenguaje xHarbour y C nativo que proporciona una interfaz gráfica a los programas escritos en xHarbour, actualmente se incorpora el compilador de C, MinGW que también es Open Source. Para más información acerca de Minigui, pueden revisar su página web oficial en: http://www.harbourminigui.com y pueden encontrar una definicion simple pero bastante completa en los siguientes enlaces:

http://www.embalajesterra.com/misdoc/programas/minigui_doc1.html
http://www.carozodequilmes.com.ar/Projects/QAC/QAC_9.htm

Un aspecto interesante a considerar es que a diferencia de Clipper, en el cual compilábamos nuestros PRG para generar un módulo OBJ, que luego enlazábamos para crear un EXE, Harbour genera un código C que es compilado y posteriormente enlazado a las librerías para generar el EXE. También es posible, dependiendo del compilador que utilicemos, generar aplicaciones para Pocket PC o para Linux, e incluso aplicaciones para 64 bits.

En lo personal, y a raíz del trabajo de Jorge López, descargué Harbour Minigui, y en los tiempos libres (que no son muchos porque cuando se tiene familia la cosa cambia), me he entretenido bastante probando a hacer pequeños programillas, y la verdad es me ha gustado mucho, el lenguaje es bastante sencillo y semi orientado a objetos, por su parte, el IDE es una gran ayuda a la hora de crear las interfaces, aunque si lo desean, pueden programar directamente el código sin utilizar el IDE.

Creo que Harbour Minigui es una excelente opción para aquellos que buscan una alternativa de migración con una curva de aprendizaje mínimo, para cuando dBFast haya cumplido su vida útil, de hecho, me han solicitado actualizar un sistema de gestión comercial y estoy pensando seriamente hacerlo con Harbour Minigui, pero tranquilos, eso no quiere decir que abandonaré dBFast o este Blog.

Saludos,

RODRIGO DINAMARCA M

Validación de usuarios con dBFast

2011-04-11T17:32:00.043-03:00

Uno de los aspectos importantes a considerar durante el desarrollo de una aplicación es la seguridad de la misma. La seguridad de una aplicación abarca diferentes aspectos entre los cuales podemos destacar los siguientes: 1) Aspectos relacionados con la prevención de errores de ejecución y "cuelgues" inesperados. 2) Aspectos relacionados con evitar la pérdida de información y errores en el proceso de entrada y salida de datos. 3) Aspectos relacionados con el control de acceso a los usuarios según su jerarquía o función dentro de la organización.

El ejemplo que hoy pongo a su disposición tiene que ver con los aspectos relacionados al control de acceso para los usuarios, y presenta una forma bastante simplificada de crear una función que muestre un cuadro de diálogo para ingresar un nombre de usuario y una contraseña. La función también busca el usuario en un archivo de datos y verifica que la contraseña ingresada coincida con la que está almacenada en el sistema.

La función ChkUser( ), encargada del control de acceso a los usuarios devuelve el valor .T. (Verdadero) si el usuario existe y la contraseña es correcta, y devuelve el valor .F. (Falso) si el usuario y/o la contraseña son incorrectos.

En el caso del ejemplo, la función ChkUser( ) impide al acceso al sistema mientras no se ingrese un nombre de usuario válido y/o una contraseña correcta; si salimos del cuadro de diálogo sin ingresar la información requerida, la función devuelve un valor falso (.F.) y se detiene la ejecución del programa. En cambio, si el valor devuelto es verdadero (.T.), se continúa la ejecución del programa y se muestra la ventana principal de la aplicación maximizada, con su correspondiente menú, fondo verde y con una imagen centrada en la ventana (que puede ser el logo de la empresa).

La aplicación utiliza tres funciones API de Windows que son:

FINDWINDOW( ): Permite buscar una ventana específica y obtener el manejador interno que le asigna Windows, almacenándolo en una variable

SHOWWINDOW( ): Permite mostrar una ventana de diferentes formas utilizando el manejador que obtuvimos mediante la función FINDWINDOW( ). El programa utiliza esta función para maximizar la ventana principal de la aplicación.

SENDMESSAGE( ): Esta función se utiliza para indicar a Windows que debe utilizar asteriscos cuando ingresemos datos en un CONTROL EDITBOX específico.

Es posible desplazarse entre los controles utilizando las teclas de dirección o la tecla "TAB".

A continuación les dejo algunas capturas de la aplicación:

En lo personal, al crear una aplicación que inicia solicitando un nombre de usuario y una clave de acceso, modifico el archivo "miaplicacion.ini" que debe ir en la carpeta "Windows", y en los parámetros relacionados con la ubicación de la ventana, establezco la posición de la ventana principal en las coordenadas (1,1), y los parámetros que manejan el alto y el ancho de la ventana, también los establezco en 1, de tal modo que la ventana principal de la aplicación queda oculta y solo se ve la ventana que solicita el usuario y la password. Si no se ingresan datos de un usuario válido y se finaliza la aplicación, la ventana principal nunca llega a mostrarse en la pantalla, por el contrario, si ingresamos un usuario válido, la ventana principal que se ha mantenido oculta se muestra maximizada. A modo de ejemplo les dejo el archivo WINSGCOM.INI correspondiente a un sistema de gestión comercial que desarrollé con dBFast.

Los parámetros "windowx" y "windowy" permiten establecer la posición inicial de la ventana, y los parámetros "windowcx" y "windowcy", el alto y el ancho de la ventana respectivamente.

Pueden descargar el ejemplo directamente desde MEGAUPLOAD:

Enlace de Descarga: http://www.megaupload.com/?d=DTRT5SO9

OBS: Tanto el nombre de usuario como la clave son "admin", todo en minúsculas y por supuesto, sin comillas.

Imágenes JPG, GIF, PNG y otros en dBFast

2011-03-09T22:18:00.004-03:00

En el artículo anterior quedó claro que una de las grandes limitaciones de dBFast radica en la escasa posibilidad de manipular imágenes y que solo reconoce archivos en formato BMP. También quedó claro que dBFast solo dispone de un set de instrucciones muy básicas para el manejo de imágenes, lo cual es una limitante a la hora de desarrollar aplicaciones que requieren un manejo gráfico más sofisticado.

Entonces las dos preguntas más recurrentes que nos hemos hecho todos en algún momento con respecto al tratamiento de imágenes son las siguientes:

¿Será posible alguna vez manipular imágenes JPG, GIF, PNG u otros formatos desde dBFast?
¿Podremos algún día manipular el tamaño de una imagen para adaptarla a una ventana?.

Hasta ahora la respuesta a estas dos preguntas ha sido un rotundo ¡NO!. Es un hecho que dBFast no puede ni podrá manipular otro formato gráfico que no sea el tradicional BMP y esa es la triste y cruda realidad.

Sin embargo, en mis años de programador he aprendido que lo que no se puede hacer, se puede emular, y si el lenguaje de programación que utilizamos no posee la herramienta adecuada para realizar un determinado trabajo, debemos buscar una herramienta externa que nos permita hacerlo sin que el usuario lo note. No por nada el lema de este Blog dice que "la mejor herramienta de programación es el ingenio del programador", y el segundo lema sería "no importa como se haga la implementación de una aplicación, siempre y cuando su funcionamiento sea transparente para el usuario", Y cuando no tenemos alternativas podemos utilizar este otro: "si no podemos alcanzar la eficiencia, debemos apostar por la eficacia".

Bajo estas premisas, me veo en la obligación de decirles que SI es posible manipular imágenes JPG, GIF, PNG, PCX, TIFF y muchos otros formatos desde dBFast. No, no estoy borracho ni drogado, para ser más exacto debería decir que podemos "hacer como que" dBfast puede trabajar con otros formatos gráficos, o como mencionaba más arriba, podemos "emular" el tratamiento de otros formatos gráficos desde dBFast.

¿Y cómo hacemos semejante acto de magia?
Tal como explicaba antes, buscando una aplicación externa que haga el trabajo por dBFast sin que el usuario lo note.

¿Y cual es entonces el ingrediente mágico?
El ingrediente mágico es el programa IRFANVIEW.

IRFANVIEW es un potente, rápido, pequeño e innovador programa de edición gráfica que lleva ya varios años en el mercado, y que tiene tres grandes atributos para los programadores que trabajan en dBFast.

Primero que todo, al igual que dBFast, IrfanView funciona con Windows 9x, ME, 2000, 2003, 2008, Vista y Windows 7.
En segundo lugar y no menos importante para nosotros, es gratuito, aunque creo que el creador se merece con creces nuestro aporte.
En tercer lugar, y lo más importante para el tema que nos interesa, es que lo podemos utilizar en modalidad de línea de comandos.

Como ven, estas tres características convierten a IRFANVIEW en el complemento ideal para delegarle el trabajo que dBFast no puede hacer.

Utilizando IRFANVIEW en modo de línea de comandos, podemos redimensionar una imagen, cambiar su formato, imprimirla, mostrar una presentación de fotografías, obtener imágenes desde un scanner y muchas cosas más que pueden ver en la excelente página argentina dedicada a IRFANVIEW: http://iv.atspace.org/pages/hlp_command_line.html

El truco entonces resulta bastante sencillo. Al igual que en el ejemplo del artículo anterior, podemos explorar las imágenes de una carpeta usando un arreglo y la función ADIR(), luego utilizamos IRFANVIEW para convertir la imagen seleccionada desde su formato original (JPG, GIF, PNG, etc.) en un archivo BMP temporal, y lo redimensionamos para que se ajuste al tamaño de la ventana de previsualización. Para finalizar cargamos el BMP temporal en una variable, lo desplegamos, y ya tenemos una vista previa de un archivo que no es BMP.

Acá les dejo algunas capturas de la implementación:

A pesar de que creo que varios de ustedes ya deben conocer las bondades de IRFANVIEW, les dejo un ejemplo de su uso con dBFast. También añado un par de opciones que permiten apreciar parte de lo que IRFANVIEW puede hacer por nosotros, y les aseguro que es difícil darse cuenta de que se está utilizando una aplicación externa para manipular las imágenes.

OBS:

El ejemplo contiene la última versión de IRFANVIEW en español más un PDF con todas las opciones y ejemplos para su uso mediante línea de comandos, IRFANVIEW es portable por naturaleza.

Las carpetas: BMP, GIF, JPG y PNG contienen las imágenes usadas en el ejemplo, la carpeta TMP contiene el archivo temporal que se genera para la vista previa. Todas las demás carpetas pertenecen a IRFANVIEW.

Los Archivos PREIVIEW.PRG, PREIVIEW.OVR, SCRLIB.PRG y DESCRIP.TXT pertenecen al ejemplo, los archivos restantes pertenecen a IRFANVIEW.

Pueden descargar el ejemplo directamente desde Megaupload:

Enlace de descarga: http://www.megaupload.com/?d=SFPS3IHW

Revísenlo y comenten.

PD:

Se ha corregido un error en la función IMGEXPLORE() detectado en el ejemplo del artículo anterior. En dicho ejemplo, al utilizar la función IMGEXPLORE() no se mostraba la primera imagen por un error en la definición del arreglo:

Código del ejemplo anterior:

***************************************************************************************
FUNCTION IMGEXPLORE()
PARAMETERS pPath

pPath = UPPER(ALLTRIM(pPath))

**********************************************

* Traspaso de nombres de archivo a un arreglo

*
DECLARE aImages[ADIR(pPath)+1]
ADIR(pPath,@aImages)
aImages[1] = "" // Esta instrucción reemplaza el primer elemento del arreglo que contiene el nombre de la primera imagen por una cadena vacía ///
...

Código corregido:

***************************************************************************************

FUNCTION IMGEXPLORE()

PARAMETERS pPath

pPath = UPPER(ALLTRIM(pPath))
nPath = ADIR(pPath)

**********************************************
* Traspaso de nombres de archivo a un arreglo
*
DECLARE aRecoverFiles[ADIR(pPath)]
ADIR(pPath,@aRecoverFiles)

**********************************************
* Traspaso de Nombres de archivo al arreglo
* que se usará para la visualización de
* longitud nElementos + 1
*
DECLARE aImages[ADIR(pPath)+1]
aImages[1] = ""
ACOPY(@aRecoverFiles,@aImages,1,nPath,2)

...

Exploradores de Imágenes con Vista Previa

2011-03-05T01:35:00.003-03:00

Después de casi 4 meses sin dedicarle tiempo al Blog, decidí echar un vistazo para ver que tal iba la cosa, pues a pesar de que de tanto en tanto miraba para ver si había algún nuevo comentario, que para mi sorpresa los hubo, o revisaba el foro de dBFast en la web del programador, no había vuelto a entrar como administrador, y si lo había hecho, había sido de manera rápida solo como para alivianar un poco la conciencia.

Hoy sin embargo, decidí ver qué pasaba en realidad y me encontré con dos gratas sorpresas. La primera es que a pesar de los largos periodos de inactividad, el Blog, a la hora que escribo esto, registra 4.123 visitas de lugares tan diversos como España (gracias amigo Ramón), Mexico, Perú, Argentina, Colombia, Ecuador, Costa Rica, Brasil, Italia, etc. etc. etc. Es decir, nada mal para un Blog orientado a una comunidad pequeña y dedicado a un lenguaje de programación que muchos consideran descontinuado y obsoleto.

La otra sorpresa que me llevé, es que por lo menos en Chile, al escribir "dbfast" en la casilla de búsqueda de Google, "dBFast - Chile" aparece en el primer lugar, y esto, sin dedicar ningún esfuerzo a ello ni habérmelo propuesto en ningún momento como meta.

En virtud de estos acontecimientos, y a pesar de que la intensa carga laboral que impone lidiar con Visual Studio.Net (si amigos, en eso estoy), con VB.Net, ASPX y ORACLE, siento que vale la pena sacrificar un par de horas de sueño para retribuir la atención y el interés que ustedes me han brindado, y quien sabe, tal vez convertir el Blog en un espacio para que cada programador pueda internacionalizar sus programas, compartiendo también parte de sus conocimientos en beneficio de todos. Espero también poder conocer de manera más cercana, aunque sea digitalmente a quienes han tenido la gentileza de apuntarse como seguidores (7 a la fecha), pues la vida pasa rápido y tendemos a no prestarle mucha atención a las personas que se cruzan en nuestras vidas.

Exploradores de imágenes con Vista Previa

Bueno, por ahora basta de reflexiones y divagaciones, y como dijo el dermatólogo, vamos al grano. Creo que en algún momento les ofrecí un par de rutinas para manipular imágenes y eso es lo que traigo hoy.

Como ya saben todos quienes han trabajado en dBFast, una de las grandes limitaciones de esta herramienta es la escasa posibilidad de manipular imágenes. dBFast solo reconoce archivos BMP (mapas de bit), que por cierto no se caracterizan por ser los más pequeños, y tampoco dispone de instrucciones o funciones que nos permitan manejar sus propiedades.

Sin embargo, y como una aplicación para Windows no puede preciarse de tal sin incluir imágenes, quiero compartir con ustedes dos funciones que creé buscando la forma de que los usuarios de mis programas pudieran incorporar sus logos o imágenes propias para personalizar la interfaz de trabajo de sus respectivas aplicaciones.

El primer problema que tuve que enfrentar, era que muchas veces el el usuario o el cliente no recordaba el nombre de la imagen que quería utilizar, y me planteaban la posibilidad de tener una vista previa de las imágenes sin tener que utilizar herramientas externas. Pero ¿y qué hacer con aquellas imágenes que eran muy grandes para acomodarlas a la interfaz de trabajo? ¿cómo haría la vista previa si no contaba con las herramientas para confinar la imagen solo a una porción la pantalla, a un objeto o para reducir sus dimensiones?.

Finalmente, encontré la solución de la misma manera en que la encontré para la creación de solapas (TAB BUTTONS), pues a quienes nos formamos programando aplicaciones para DOS se nos olvida que la base del funcionamiento de Windows son la ventanas. En ambos ejemplos creé una ventana principal para la aplicación, dentro de ella creé el o los objetos que permiten buscar y listar las imágenes, e incorporé una ventana anidada (hija) o CHILD WINDOW en la cual mostraría la imagen, de esa manera, para ver las diferentes imágenes solo debía limpiar y actualizar la ventana hija.

Pero ¿como mostraría aquellas imágenes que fueran más grandes que la ventana destinada a la vista previa si dBFast no me permite manipular las dimensiones de salida de una imagen para adaptarlas a un objeto o contenedor? La solución era más fácil de lo que pensaba, puse dos barras de desplazamiento o SCROLL BARS, una vertical y otra horizontal junto a la ventana de la vista previa, de modo que al desplazarse sobre ellas se fuera desplazando la imagen dentro de la ventana, quizás no es lo óptimo, pero el resultado es aceptable.

A continuación les dejo algunas capturas de la ejecución del programa "PREVIEW.PRG" para que puedan apreciar de qué hablo:


Ventana principal de la aplicación

Imagen seleccionada - Ejemplo1

Imagen seleccionada y uso de barras de desplazamiento para ver la parte oculta de la imagen - Ejemplo 1

Imagen seleccionada - Ejemplo 2

Imagen seleccionada en carpeta "Fotos" y uso de barras de desplazamiento para ver la parte oculta de la imagen - Ejemplo 2

Archivos incluidos en la descarga: PREVIEW.PRG (Programa principal), SCRLIB.PRG (Biblioteca de funciones), EVENTS.INC (Archivo con definiciones de eventos), DESCRIP.TXT (Texto con descripción de la aplicación para mostrar en ventana principal del programa), y varios archivos de imagen .BMP

Pueden descargar el programa directamente desde Megaupload.

Enlace de descarga: http://www.megaupload.com/?d=A6X6TBS0

Instalador RPV Printing System 2.2 en español

2010-11-08T00:41:00.003-03:00

Buscando otra cosa, encontré casualmente en http://www.archivospc.com, el instalador de RPV Printing 2.2 también en versión FREE.

A pesar de que el generador de informes incluido con dBFast, CA-RET es bastante potente y versátil, no está demás echarle un vistazo a RPV, pues esta mezcla de lenguaje y aplicación para la generación de informes tiene algunas características bien interesantes.

Como dato les puedo decir que tuve algunos problemas para que RPV funcionara correctamente en Windows Vista y Windows 7, pero actualmente y con las actualizaciones de Windws 7, me funciona a la perfección.

Pueden descargar esta aplicación desde la sección "Recursos" del Blog.

Saludos,

RODRIGO DINAMARCA M.

El Futuro de dBFast en las tecnologías de 64 bits

2010-11-07T20:28:00.002-03:00

Hola a todos, ha pasado bastante tiempo desde el último post, que para colmo era una corrección del post anterior. La verdad es que he tenido bastante trabajo y no he podido dedicarme al Blog, por eso, y porque me siento un poco en deuda, quiero exponer algunas reflexiones respecto al futuro de dBFast, y no solo de dBFast, sino también de las herramientas de desarrollo que permiten a aquellos que comenzamos programando aplicaciones para DOS, generar aplicaciones para Windows en herramientas de 16 bits.

Hace un tiempo, Ramón Denuc, uno de los desarrolladores emblemáticos de dBFast en España, y que siempre ha estado dispuesto a compartir sus experiencias y conocimientos con el resto de nosotros a través del foro de dBFast en la web del programador, me preguntaba si había intentado ejecutar alguna aplicación hecha con dBFast en algún Windows de 64 bits. La verdad es que, a pesar tener equipos con procesadores de 64 bits, utilizo Windows 7 Ultimate de 32 bits, y siempre he utilizado Sistemas Operativos de 32 bits.

Como la pregunta de Ramón me pareció bastante lógica, pues encierra una preocupación que deberíamos tener todos los que utilizamos alguna herramienta de 16 bits, me puse a investigar y la respuesta más coherente la encontré en un foro de consulta de Microsoft del cual les dejo el enlace: http://social.technet.microsoft.com/Forums/es-ES/wcvistaes/thread/a5fc4e7d-e369-43e4-9fa3-034ee007cee8.

En este foro se indica que un Windows de 64 bits, bajo un procesador de 64 bits, no puede ejecutar aplicaciones de 16 bits porque la arquitectura del procesador no se lo permite. Sin embargo, esto dependerá del modo en el cual trabaja el procesador, entendiéndose que al instalar un S.O. de 64 bits, el procesador en forma automática usará el "Long Mode", el cual, aunque se utilice en modo de compatibilidad, ejecutará aplicaciones de 32 bits pero nunca de16 bits. Por otra parte, si instalamos un S.O. de 32 bits en el procesador de 64 bits, este funcionará en "Legacy Mode", lo cual será igual a tener un procesador de 32 bits aunque con mejoras en el rendimiento y nos permitirá ejecutar aplicaciones de 16 bits.

Pero, ¿y que se espera de Windows en el Futuro? A pesar de que el fracaso de Windows Vista nos hizo pensar que las cosas se mantendrían estables durante un buen tiempo, el éxito que ha logrado Windows 7, sobre el cual funcionan sin problema nuestras aplicaciones hechas en dBFast si debería preocuparnos un poco, pues existen rumores de que Windows 7 será el último S.O. de Microsoft que soportará arquitecturas de 32 bits y por lo tanto, el último en ser compatible con aplicaciones de 16 bits de forma nativa. Si a esto le sumamos los rumores que plantean que Microsoft también abandonará Foxpro, que hasta hoy ha sido su herramienta de desarrollo xBase emblemática, podemos deducir que con la salida de Bill Gates, la compañía ha decidido dar un brusco vuelco en su estrategia de negocios, apostando fuertemente por las herramientas de desarrollo .NET y por las tecnologías WEB.

Pero no podemos culpar a Microsoft por este tipo de decisiones pues están enfocando su apuesta hacia las tendencias que marca el avance de la tecnología. Por su parte, el extraordinario avance en el desarrollo de microprocesadores logrado por INTEL y AMD avalan esta lógica.

En lo personal creo que el próximo S.O. de Microsoft tendrá versiones de 32 y 64 bits al igual que Windows 7, principalmente porque la capacidad de aprovechamiento que los usuarios tienen de las nuevas tecnologías no va a la par de sus avances, y que por lo tanto, a nuestras aplicaciones aún les queda vida por delante. No obstante, debemos ser conscientes de que somos los dinosaurios de la programación, y que hasta ahora hemos logrado sortear con éxito los riesgos de la extinción, y aunque existan alternativas como las máquinas virtuales y los emuladores que nos permitirán prolongar la existencia de nuestros programas, solo estamos retrasando el proceso creando una isla jurásica en el mar de la modernidad.

bueno amigos, en todo caso, mientras eso no ocurra, seguiré desarrollando aplicaciones en dBFast, y en una de esas, siguen funcionando en tecnologías de 64, 128, y chorrocientos mil bits.

Les dejo también el siguiente artículo para que lo revisen: http://culturacion.com/etiqueta/64-bits

Saludos,

RODRIGO DINAMARCA M.

Error detectado en Artículo: Uso de solapas para administrar archivos de datos en una interfaz basada en CONTROL BROWSE y PICTURE BUTTONS

2010-10-18T23:48:00.001-03:00

Hola a todos, para aquellos que hayan descargado la aplicación de ejemplo incluida en el artículo: "Uso de solapas para administrar varios archivos de datos en una interfaz basada en CONTROL BROWSE y PICTURE BUTTON", les informo que existe un error en la función ADDMODIFY( ), la cual controla la creación de nuevos registros y la modificación de los ya existentes.

El error está en las líneas de código encargadas de desplegar los botones "Aceptar" y "Cancelar", pues donde dice:

CREATE PICTURE BUTTON "Aceptar" AT nWAMAlto-1,nWAMAncho-24 FROM FILE \BYP\GUI\ACEPTAR.BMP
CREATE PICTURE BUTTON "Cancelar" AT nWAMAlto-1,nWAMAncho-12 FROM FILE \BYP\GUI\CANCELAR.BMP

Debería decir solamente:

CREATE PICTURE BUTTON "Aceptar" AT nWAMAlto-1,nWAMAncho-24 FROM FILE ACEPTAR.BMP
CREATE PICTURE BUTTON "Cancelar" AT nWAMAlto-1,nWAMAncho-12 FROM FILE CANCELAR.BMP

La ruta especificada "\BYP\GUI\", corresponde a la ubicación de los archivos de imagen utilizados como botones en la aplicación original desde la cual se extrajo el ejemplo, y no existe en la carpeta del ejemplo, lo cual provocará un error al compilar, o bien, al tratar de añadir o modificar registros.

Un saludo y disculpen el despiste.

RODRIGO DINAMARCA M.

Uso de solapas para administrar archivos de datos en una interfaz basada en CONTROL BROWSE y PICTURE BUTTONS.

2010-10-13T20:58:00.000-03:00

Después de un buen tiempo sin dedicarme al Blog, me he logrado hacer de tiempo para publicar algo nuevo, pero como me dijo Ramón Denuc y con justa razón, "primero las obligaciones y luego las devociones".

Bueno, el tema pendiente era utilizar solapas para gestionar más de un archivo a la vez, y como casi siempre nos encontramos con que al desarrollar una aplicación, necesitamos utilizar dentro de la categoría de los Archivos Maestros, plantillas que delimitarán las opciones o parámetros bajo los cuales funcionará nuestro sistema como por ejemplo: un archivo de colores, un archivo de marcas o modelos de artículos, o categorías (también llamadas "familias") de artículos, formas de pago o cosas por el estilo, hay que reconocer que es una tortura china para el usuario tener que entrar a una opción distinta cada vez que debe ingresar los datos de cada uno de estos archivos, porque más encima, si no los ingresa, el sistema dará tumbos.

La verdad es que para el desarrollador también es una soberana joda implementar las utilidades para la mantención de cada uno de estos archivos, y por esa razón, les dejo un ejemplo bastante simplificado para manejar estas plantillas desde una única interfaz utilizando solapas. El ejemplo está basado en el mismo diseño que la utilidad para la mantención de usuarios, y como lo que haremos será mostrar listados de datos con la instrucción CREATE CONTROL BROWSE, no necesitaremos utilizar distintas ventanas para mostrar los archivos, sino que bastará con mostrar u ocultar el CONTROL BROWSE correspondiente con SHOW CONTROL y HIDE CONTROL, lo que queda es realizar las evaluaciones y verificaciones dependiendo de la solapa que se encuentre activa.

A continuación les dejo algunas capturas de la aplicación:

Pueden descargar el programa de ejemplo directamente dede MEGAUPLOAD.

Enlace de descarga: http://www.megaupload.com/?d=22TUEO66

Tema del próximo artículo:

Explorador de imágenes (.BMP) con vista previa.

OBS:

Para seguir publicando artículos, es necesario el apoyo de los lectores mediante comentarios, o registrándose como seguidores del Blog. También se puede cooperar proponiendo o solicitando temas y/o recursos de programación. Toda iniciativa tendrá fuerza en la medida de que los interesados participen activamente. Saludos y agradecido desde ya.

Gestión de Archivos Maestros con interfaz basada en CONTROL BROWSE e IMAGE BUTTONS

2010-09-09T19:59:00.003-04:00

Retomando el Blog después de casi dos semanas de no publicar nada (mi casa parecía hospital, estábamos todos enfermos) y esperando también que en estas dos semanas hayan podido digerir los distintos ejemplos y recursos publicados, pongo a su disposición un programa que tal vez no representa una novedad, pero que puede resultar útil a la hora de manipular archivos maestros en sus aplicaciones, con una interfaz sencilla y un pequeño toque visual.

El programa permite manipular (gestionar y mantener) un archivo maestro de usuarios,y su interfaz está basada en un CONTROL BROWSE, PICTURE BUTTONS, un CONTROL EDITBOX para la búsqueda de registros y un CONTROL RADIOBUTTON para seleccionar el índice activo.

A continuación les dejo algunas capturas de la ejecución del programa:

Como ustedes saben, dBFast no permite utilizar el mandato BROWSE o el comando CREATE CONTROL BROWSE si el archivo de datos que estamos desplegando se encuentra vacío. Para solucionar este problema y evitar el mensaje de error, el programa evalúa si el archivo contiene registros, y si no contiene, agrega uno en blanco el cual se elimina en forma inmediata. El mandato SET DELETED ON, se encarga de que ese registro no se muestre, pero permite que se muestre el CONTROL BROWSE en blanco. Además, si el archivo está vacío o contiene solo registos eliminados, se procede a desactivar todos los controles para la manipularción de registros, y mediante SELECT CONTROL se fija el foco en el botón "Nuevo" (que permite agregar nuevos registros). Al estar seleccionado el botón "Nuevo", basta con presionar la tecla "Enter" para agregar un nuevo registro, después de lo cual, el foco regresa al botón para seguir agregando registros mediante el teclado.

Pueden descargar el programa de ejemplo directamente dede MEGAUPLOAD.

Enlace de descarga: http://www.megaupload.com/?d=KXO2RXV7

Tema del próximo artículo:

Uso de solapas para administrar varios archivos de datos en una interfaz basada en CONTROL BROWSE y PICTURE BUTTONS como la de este ejemplo.

OBS:

Para seguir publicando artículos, es necesario el apoyo de los lectores mediante comentarios, o registrándose como seguidores del Blog. También se puede cooperar proponiendo o solicitando temas y/o recursos de programación. Toda iniciativa tendrá fuerza en la medida de que los interesados participen activamente. Saludos y agradecido desde ya.

Recursos: Utilidades para la generación de Informes

2010-08-30T01:48:00.004-04:00

En la sección "Recursos", he puesto a disposición de los usuarios, los enlaces de descarga para dos aplicaciones orientadas a la generación de informes.

No2Imp: Permite ejecutar aquellos viejos informes que dirigíamos hacia LPT1 con el mandato "?", acepta códigos para el tamaño de los caracteres, e imprime en cualquier impresora instalada en Windows, incluso las que están conectadas a los puertos USB.

RPV Printing System: Es un potente gestor de impresión que incluye un lenguaje propio para la generación de informes, un servidor de impresión que gestiona la ejecución de nuestros listados, y una herramienta para la visialización de informes. Entre otras cosas, permite colores, imágenes, trazado de líneas y códigos de barras. Como el instalador se me dañó con los años, puse en la carpeta RPV los ejecutables, las DLLs y los archivos OCX necesarios para que la aplicación funcione correctamente.

Si CARET te ha quedado corto, si quieres volver a utilizar los viejos listados creados con el comando "?", o si quieres listados profesionales alternativos a todo lo que dBFast ofrece, estos dos programas pueden ser la solución.

Ir a Recursos >>

Abrir utilidades para cambiar Fecha y Hora del sistema, y Configuración Regional

2010-08-25T12:34:00.002-04:00

Siguiendo la línea del artículo anterior, les dejo otro ejemplo de uso del RUNDLL32.EXE de Windows para llamar utilidades del Panel de Control almacenadas en el archivo SHELL32.DLL.

En esta oportunidad, les dejo otro pequeño ejemplo que permite abrir la utilidad para cambiar la Fecha y Hora del sistema. Agregué otra función que permite invocar la utilidad para cambiar la Configuración Regional.

A modo de Bonus Track, incluyo una función que permite Abrir y Cerrar una unidad de CD/DVD utilizando la función API mciSendString( ), contenida en el archivo MMSYSTEM.DLL.

A continuación les dejo el código fuente del ejemplo:

********************************************************************************************
* Programa   : DATETIME
* Descripción: Permite abrir la utilidad para cambiar fecha y hora de Windows,
*              se añadió utilidad para configuración regional y función para abrir y cerrar
*              unidad de CD/DVD.
* Autor      : Rodrigo Dinamarca M.
* Obs.       : Probado en Windows 7
********************************************************************************************

SET PROCEDURE TO DATETIME
SET ERASE VIDEO TO 112

ERASE

cB1 = "Establecer Fecha y Hora"
cB2 = "Configuración Regional"
cB3 = "Cerrar"
cB4 = "* Bonus Track: ABRIR Unidad de CD/DVD"
cB5 = "* Bonus Track: CERRAR Unidad de CD/DVD"
CREATE BUTTON cB1 AT 2,5 SIZE 2,45
CREATE BUTTON cB2 AT 5,5 SIZE 2,45
CREATE BUTTON cB3 AT 8,5 SIZE 2,45
CREATE BUTTON cB4 AT 11,5 SIZE 2,45

DO WHILE .T.
   nEvent = CHKEVENT()
   DO CASE
      CASE nEvent = 1
           IF LASTKEY() = 27
              EXIT
           ENDIF
      CASE nEvent = 5
           EXIT
      CASE nEvent = 6
           DO CASE
              CASE BUTTON() = cB1
                   SetDateTime()
              CASE BUTTON() = cB2
                   RegionalConfig()
              CASE BUTTON() = cB4
                   REPLACE CONTROL cB4 WITH cB5
                   OpenCDDVD(1)
              CASE BUTTON() = cB5
                   REPLACE CONTROL cB5 WITH cB4
                   OpenCDDVD(2)
              OTHERWISE
                   EXIT
           ENDCASE
   ENDCASE
ENDDO

RETURN

****************************************
FUNCTION SetDateTime()

* WRUN c:\windows\rundll32.exe c:\windows\system\shell32.dll,Control_RunDLL timedate.cpl @0,0 // FECHA Y HORA para Windows 95 y 98
WRUN C:\WINDOWS\SYSTEM32\RUNDLL32.EXE C:\WINDOWS\SYSTEM32\SHELL32.DLL,Control_RunDLL timedate.cpl @0,0

RETURN("")

****************************************
FUNCTION RegionalConfig()

*WRUN c:\windows\rundll32.exe c:\windows\system\shell32.dll,Control_RunDLL intl.cpl @0,0 // CONFIGURACIÓN REGIONAL para Win 95/98
WRUN C:\WINDOWS\SYSTEM32\RUNDLL32.EXE C:\WINDOWS\SYSTEM32\SHELL32.DLL,Control_RunDLL intl.cpl @0,0 // CONFIGURACIÓN REGIONAL

RETURN("")

****************************************
FUNCTION OpenCDDVD() // ABRIR Y CERRAR LA PUERTA DEL LECTOR DE CD
PARAMETERS p_nAction

DECLARE PFUNC mciSendString RETURNING INTEGER IN DLL mmsystem.dll

IF EMPTY(PCOUNT())
   p_nAction = 1
ENDIF

returnstring = SPACE(127)

IF p_nAction = 1
   errornum = mciSendString("set CDAudio door open", ALLTRIM(returnstring), toint(127), toint(0))
ELSE
   errornum = mciSendString("set CDAudio door closed", ALLTRIM(returnstring), toint(127), toint(0))
ENDIF

IF errornum <> 0
   MESSAGE("Operación Cancelada","No se ha establecido contacto con la unidad de CD/DVD")
ENDIF

RETURN("")

También les dejo algunas capturas de la ejecución del ejemplo:

Controles de la Aplicación

Utilidad para cambiar Fecha y Hora abierta desde la aplicación

Utilidad para cambiar la Configuración Regional abierta desde la aplicación

Pueden descargar el programa de ejemplo directamente dede MEGAUPLOAD.

Enlace de descarga: http://www.megaupload.com/?d=R0K3EITF

Tema del próximo artículo:

Uso de solapas para administrar visualización de controles.

OBS:

Para quienes hayan descargado el Anuario de ejemplo: para una correcta ejecución copiar la carpeta "Anuario", la que contiene la aplicación, en la raíz del disco C:

Para seguir publicando artículos, es necesario el apoyo de los lectores mediante comentarios, o registrándose como seguidores del Blog. Toda iniciativa tendrá fuerza en la medida de que los interesados participen activamente. Saludos y agradecido desde ya.

Verificar resolución y cambiar propiedades de pantalla de Windows

2010-08-23T11:38:00.005-04:00

Un problema frecuente al que nos enfrentamos cuando diseñamos nuestras aplicaciones, es el espacio disponible en nuestras ventanas para mostrar la información adecuadamente, o bien, para ubicar los objetos y controles destinados a recibir la información que debe introducir el usuario.

Como soy un poco maniático y perfeccionista, considero muy importante mantener el equilibrio entre la funcionalidad y la estética de una aplicación, pues a través de la experiencia, he comprobado que los clientes valoran la funcionalidad de los programas, pero agradecen la claridad y la simpleza de una interfaz intuitiva, que facilite su interacción con el sistema, y que facilite también su correspondiente curva de aprendizaje.

Volviendo al problema del espacio para ubicar nuestros objetos en las ventanas, decidí dejar de adaptar mis programas a las resoluciones más bajas, y al igual como lo hacen otros desarrolladores de software, decidí poner requerimientos mínimos de resolución de pantalla para ejecutar mis programas. Esta decisión la tomé basándome en que el hardware para gráficos existente hoy en día es cada vez más potente, y que las resoluciones soportadas por los monitores han aumentado considerablemente gracias a los estándares que apuestan por la Alta definición.

El siguiente paso para resolver el problema del espacio y del tamaño de las ventanas, fue crear una función específica para detectar si el equipo en el cual estaba instalado el software, cumplía con la resolución mínima especificada en sus requerimientos. Este paso resultó bastante simple porque en dBFast existe la función HARDWARE( ), que con los parámetros adecuados y entre otras cosas, permite obtener el ancho y el alto de la pantalla en pixeles.

Una vez implementada la función, ¿qué haría, además de mostrar el diálogo de error correspondiente, en el caso de que la resolución de pantalla del equipo no fuera la adecuada?. Lo primero que se me pasó por la mente fue abrir el panel de control con WRUN CONTROL.EXE para que el usuario accediera a las opciones de pantalla, y cambiara la resolución desde la opción correspondiente, sin embargo, en mi condición de maniático, esta solución no me satisfacía pues quería llegar directamente a la utilidad de configuración de pantalla de Windows. Me puse a pensar e investigar para encontrar una forma de abrir las diferentes opciones de pantalla de windows directamente desde dBFast, y me preguntaba cómo lo lograría pues las opciones del Panel de Control están almacenadas en la librería SHELL32.DLL y dBFast no puede interactuar con DLLs de 32 bits.

Finalmente encontré la solución, la cual consiste en utilizar la potencialidad del programa RUNDLL32.EXE de Windows, pues, dado que no puede ejecutarse directamente una función almacenada en una DLL, Windows utiliza el programa RUNDLL32.EXE para lanzar funciones almacenadas en sus archivos DLL compartidos. Luego, tuve que buscar los archivos CPL utilizados por el Panel de Control para dar con aquellos que me permitieran interactuar con las opciones de pantalla, y crear la función o procedimiento que me permitiera llegar a ellas directamente desde mi aplicación.

Para probar lo anterior, escribí un pequeño programa de prueba que me funcionó a la perfección en Windows XP, Windows Vista y Windows 7, el único cuidado que debemos tener, es verificar la ubicación del RUNDLL32.EXE y del SHELL32.DLL, pues esta puede cambiar dependiendo de la versión de Windows que utilicemos, de la unidad de disco en que esté instalado el sistema operativo, y del nombre de la carpeta en la cual está el Sistema Operativo.

El código fuente del programa es el siguiente:

***************************************************************************************************
* Programa   : SETSCR.PRG
* Descripción: Permite el acceso a las opciones de pantalla del Panel de Control
* Autor      : Rodrigo Dinamarca M.
***************************************************************************************************

SET ERASE VIDEO TO 112
SET PROCEDURE TO SETSCR

ERASE

IF ChkScrRes(1024,768) // Verifica la resolución mínima de pantalla de 1024 x 768
   MESSAGE("Resolución de Pantalla adecuada para el Sistema","El mínimo requerido es de 1024 x 768")
ELSE
   SetScreen(4) // Abre la utilidad para cambiar la resolución de pantalla de Windows
ENDIF

**************************************************************
* Creación de Botones para acceder a las Opciones de Pantalla

cB1 = "Configurar Íconos del Escritorio"
cB2 = "Configurar Protector de Pantalla"
cB3 = "Personalizar Escritorio"
cB4 = "Configurar Resolución de Pantalla"

CREATE BUTTON cB1 AT 3,5 SIZE 2,45
CREATE BUTTON cB2 AT 6,5 SIZE 2,45
CREATE BUTTON cB3 AT 9,5 SIZE 2,45
CREATE BUTTON cB4 AT 12,5 SIZE 2,45
CREATE BUTTON "Cerrar" AT 15,5 SIZE 2,45

DO WHILE .T.
   nEvent = CHKEVENT()
   DO CASE
      CASE nEvent = 1 // Teclado
           IF LASTKEY() = 27
              EXIT
           ENDIF
      CASE nEvent = 5 // Botón de cierre de la ventana
           EXIT
      CASE nEvent = 6 // Botón de comando
           DO CASE
              CASE BUTTON() = cB1
                   SetScreen(1)
              CASE BUTTON() = cB2
                   SetScreen(2)
              CASE BUTTON() = cB3
                   SetScreen(3)
              CASE BUTTON() = cB4
                   SetScreen(4)
              CASE BUTTON() = "Cerrar"
                   EXIT
           ENDCASE
   ENDCASE
ENDDO

RETURN

******************************************************************
* Función para interactuar con las opciones de pantalla de Windows

FUNCTION SetScreen()
PARAMETERS p_nOption

DO CASE
   CASE p_nOption = 1
         * Para Windows 95/98 utilizar -> WRUN c:\windows\rundll32.exe c:\windows\system\shell32.dll,Control_RunDLL desk.cpl @0,0
         WRUN C:\WINDOWS\SYSTEM32\RUNDLL32.EXE C:\WINDOWS\SYSTEM32\SHELL32.DLL,Control_RunDLL desk.cpl @0,0
   CASE p_nOption = 2
         * Para Windows 95/98 utilizar -> WRUN c:\windows\rundll32.exe c:\windows\system\shell32.dll,Control_RunDLL desk.cpl @0,1
         WRUN C:\WINDOWS\SYSTEM32\RUNDLL32.EXE C:\WINDOWS\SYSTEM32\SHELL32.DLL,Control_RunDLL desk.cpl @0,1
   CASE p_nOption = 3
         * Para Windows 95/98 utilizar -> WRUN c:\windows\rundll32.exe c:\windows\system\shell32.dll,Control_RunDLL desk.cpl @0,2
         WRUN C:\WINDOWS\SYSTEM32\RUNDLL32.EXE C:\WINDOWS\SYSTEM32\SHELL32.DLL,Control_RunDLL desk.cpl @0,2
   CASE p_nOption = 4
         * Para Windows 95/98 utilizar -> WRUN c:\windows\rundll32.exe c:\windows\system\shell32.dll,Control_RunDLL desk.cpl @0,3
         WRUN C:\WINDOWS\SYSTEM32\RUNDLL32.EXE C:\WINDOWS\SYSTEM32\SHELL32.DLL,Control_RunDLL desk.cpl @0,3
ENDCASE

RETURN("")

******************************************************************
* Función para verificar la resolución de pantalla de Windows

FUNCTION ChkScrRes()
PARAMETERS p_nAnchoScr, p_nAltoScr

lScrReturn = .T.
nScrVerSize = HARDWARE(1)
nScrHorSize = HARDWARE(2)

IF (nScrVerSize < p_nAltoScr) .OR. (nScrHorSize < p_nAnchoScr)
   lScrReturn = .F.
ENDIF

RETURN(lScrReturn)

Algunas capturas de la ejecución del programa:

Mensaje enviado por la aplicación cuando la resolución de pantalla es la correcta.

Botones de comando que permiten acceder a cada una de las opciones de pantalla de Windows sin pasar por el Panel de Control.

Ventana de la utilidad para configurar la resolución de pantalla abierta desde el botón de comando de la aplicación.

Pueden descargar el programa de ejemplo directamente dede MEGAUPLOAD.

Enlace de descarga: http://www.megaupload.com/?d=S0IW9YZS

Tema del próximo artículo:

Cambiar fecha y hora del sistema desde dBFast, usando las utilidades de Windows.

OBS:

Para seguir publicando artículos, es necesario el apoyo de los lectores mediante comentarios, o registrándose como seguidores del Blog. Toda iniciativa tendrá fuerza en la medida de que los interesados participen activamente. Saludos y agradecido desde ya,

Uso de "Solapas" (Tab Buttons) en dbFast utilizando CHILD WINDOWS

2010-08-21T14:07:00.000-04:00

Como todos ustedes saben, una de las limitaciones de dbFast, además de generar aplicaciones de 16 bits, es que no incluye controles que nos permitan utilizar "solapas" o "pestañas", también conocidas como "Tabs" o "Tab Buttons".

Uso de Solapas según Stephen Field

Encontré una vieja rutina creada por Stephen Field, era una demo de varias aplicaciones y entre ellas, había una que utilizaba "solapas" para mostrar distintas páginas de información en una misma ventana.

Utilizando el comando CREATE TOOLBAR BUTTON, Stephen Field logra emular el funcionamiento de las "solapas", pero cada vez que cliqueamos sobre una de ellas, debemos limpiar la ventana con el comando ERASE y redibujar su contenido, lo cual resulta poco práctico, el rendimiento es deficiente, y el cambio no se ve estéticamente bien, pues genera un parpadeo notorio cuando debemos redibujar una ventana que contiene muchos objetos.

Implementación de Solapas usando PICTURE BUTTON y CHILD WINDOW

Buscando otra forma de implementar solapas, me di cuenta de que el principal problema era utilizar comandos GET dentro de las solapas. A diferencia de los controles, que pueden ser ocultados con la orden HIDE CONTROL, los comandos GET no pueden ser ocultados, la única opción era eliminarlos con CLEAR GETS al cambiar de solapa, y volver a crearlos al entrar nuevamente en la solapa que los contenía.

Pensando y pensando, llegué a la conclusión de que, como la base del funcionamiento de Windows son las ventanas, lo lógico era probar poniendo la información de las solapas en ventanas, así que partí creando una ventana principal que sirviera de contenedor, puse en ella unos botones de imagen o PICTURE BUTTON con la imagen de cada solapa, y creé una serie de ventanas dependientes o ventanas "hijas" (CHILD WINDOW) que se van mostrando u ocultando a medida que pulsamos en los PICTURE BUTTON que actúan como solapas. El resultado fue el siguiente:

Vista de la primera Solapa

Vista de la segunda Solapa

Vista de la tercera Solapa

Una vez implementadas las solapas, agregué la funcionalidad de cambiar de solapa mediante teclado, utilizando las teclas <RePág> y <AvPág>.

Como el resultado fue bastante aceptable, quiero compartir un enlace para descargar el ejemplo anterior , el cual incluye el código fuente del programa y todos los elementos necesarios para ejecutarlo y probarlo. Traté de no utilizar muchas funciones externas para una mejor comprensión del código, sin embargo, utilicé algunas contenidas en otro PRG que también está incluido en el archivo RAR, disponible para descargar desde MEGAUPLOAD.

Enlace de descarga: http://www.megaupload.com/?d=JTPXHHQB

Tema del próximo artículo:

Detectar la resolución de video, y abrir la utilidad de configuración de pantalla de Windows desde dbFast.

OBS:

Para seguir publicando artículos, es necesario el apoyo de los lectores mediante comentarios, o registrándose como seguidores del Blog. Toda iniciativa tendrá fuerza en la medida de que los interesados participen activamente. Saludos y agradecido desde ya,

RODRIGO DINAMARCA M.

La transición de un programador de lenguajes xBase para DOS a WINDOWS, un poco de Historia

2010-08-19T18:02:00.000-04:00

Como programador de la vieja escuela, aquella en donde reinaba DOS en las computadoras personales, y Unix o Xenix en los grandes computadores de la Universidad, pasé por una amplia gama de lenguajes de programación, entre ellos PASCAL, FORTRAN, COBOL o C, sin olvidar a BASIC en sus versiones MBASIC, GWBASIC, QBASIC y TURBO BASIC.

Luego, cuando comencé a desarrollar aplicaciones de gestión, me encontré con un sencillo lenguaje interpretado, incorporado dentro de un potente gestor de Bases de Datos llamado dBase III Plus, el cual organizaba los archivos de datos en un innovador formato con la extensión .DBF, y que además permitía manejar muy fácilmente las tablas de índices, tarea engorrosa hasta entonces en otros lenguajes. Posteriormente aparecieron otras alternativas a dBase que utilizaban los mismos formatos para el manejo de bases de datos y una sintaxis similar para la programación, destacando entre ellos un confiable FoxPro, y un potente compilador para dBase que cobró vida propia bajo el nombre de Clipper. Todos estos lenguajes derivados del dBase, recibieron la denominación de lenguajes xBase, y se popularizaron entre los programadores en forma paralela al desarrollo de Windows, que para entonces pasaba de ser un ambiente operativo que corría sobre DOS, a ser el Sistema Operativo más usado en el mundo.

La creciente demanda de Windows hizo evidentes sus limitaciones para adaptarse a los nuevos estándares y a la aparición de nuevo y más potente hardware. Windows luchaba por sacar el DOS que llevaba en su ADN pues era su principal lastre -cosa que veíamos con preocupación-, y asimilar los genes perfeccionados de un medio hermano, nacido como consecuencia de la fallida relación entre Microsoft e IBM en la búsqueda de una promesa llamada OS2. Este medio hermano era Windows NT, y se convirtió en la base de lo que conocimos como Windows 2000, Windows XP, y los actuales VISTA y 7.

Como bien sabemos, la evolución de Windows afectó drásticamente el desarrollo de aplicaciones en lenguajes para DOS, y nos vimos enfrentados a una nueva generación de lenguajes cuya creación y funcionamiento estaban basados íntegramente en la orientación a objetos. En estos nuevos lenguajes predominaba una interfaz gráfica sobre la cual diseñábamos ventanas, y programábamos porciones de código que representaban acciones en respuesta a eventos que afectaban a los objetos o elementos la interfaz. También conectábamos diferentes formatos de bases de datos gracias a la magia de algo llamado ODBC.

Para aquellos de nosotros que habíamos adoptado alguno de los lenguajes xBase para DOS, este cambio representó un duro golpe. No era fácil pasar de las líneas de código propias de nuestros PRG, a los proyectos gráficos, y la curva de adaptación (más que la curva de aprendizaje) se hizo muy difícil de remontar. Ya no teníamos el control de todo nuestro programa, no podíamos manejar los puertos de comunicaciones, tampoco podíamos controlar los procesos de impresión como lo hacíamos antes. Estando así las cosas, nos vimos enfrentados a la tarea de buscar una opción para migrar nuestras aplicaciones a Windows, o bien, a ingeniarnos para solucionar estos problemas y mantenernos firmes con nuestro lenguaje favorito. Aparecieron distintas alternativas, unas mejores que otras, y aunque muchos opinen lo contrario, la adaptación a un nuevo lenguaje o el uso de una librería que nos permitiera acceder al desarrollo de aplicaciones windows, representaban cambios de sintaxis, nuevos objetos, definiciones o declaraciones que modificaban drásticamente el lenguaje al cual estábamos acostumbrados. Ni siquiera la aparición del desafortunado dBase V para Windows, nacido de la mano de Borland, representó una alternativa adecuada para nuestra migración.

¿En qué estamos ahora? muchos usuarios de Clipper adoptaron librerías mágicas como Clip4win o Fivewin, que transformaban sus aplicaciones DOS a Windows de 16 bits, luego, muchos de ellos migraron a Harbour para superar el obstáculo que impusieron las tecnologías de 32 bits. En cuanto a los usuarios de Foxpro, muchos migraron a Visual Foxpro, el resto de los usuarios trataron de migrar a otras opciones menos afortunadas como CA Visual Objects, o bien, continuaron firmemente aferrados al desarrollo en DOS.

¿Y yo? pues yo conocí un software de desarrollo bastante liviano y fácil de entender, aunque está dentro de la categoría correspondiente a las alternativas "menos afortunadas", esta opción me permitió migrar fácilmente aplicaciones hechas en Clipper a entornos Windows, pues su sintaxis y forma de programación lo dejaba a medio camino entre los lenguajes basados en interfaces gráficas y aquellas basadas en líneas de código. Esta herramienta de desarrollo hacía transparente para aquellos programadores como yo, acostumbrados a la programación estructurada, pero lineal, los elementos de la programación basada en objetos y eventos, e incluia una rudimentaria herramienta para diseñar aplicaciones en forma gráfica que rara vez utilicé. Bueno amigos, ustedes ya lo saben por el título del Blog, mi elección fue CA-dBFast (de Computer Associates), y a pesar de que por requerimientos laborales tuve que migrar a Visual Basic y Visual Foxpro, además de plataformas empresariales más específicas y potentes como SYBASE, SQL y Powerbuilder, me reencontré con este viejo conocido y recordé los años en que probaba funciones y líneas de código que se traducían en aplicaciones Windows. Así pues, la nostalgia me llevó a crear este Blog cuyo objetivo es compartir con aquellos incondicionales de dBFast, mis experiencias y descubrimientos para dotar a este lenguaje, de herramientas y potencialidades que algunos dicen que no posee, pero que con ingenio se pueden implementar.

A pesar de que algunos me dicen que estas son palabras al viento y líneas perdidas, estoy convencido de que la mejor herramienta es aquella que sabemos usar y que nos permite hacer el trabajo, independientemente de que haya mejores o peores, así que espero, humildemente su colaboración y comentarios para demostrar que dbFast sigue vivo y que aquella aplicación creada para Windows 3.1, aún funciona bien en Windows 95, 98, ME, NT, 2000, XP, VISTA y 7, sin modificaciones, services pack o librerías adicionales.

Para finalizar y para premiarlos por su paciencia al leer estas líneas, quiero compartir con ustedes una aplicación sacada directamente del disco duro de los recuerdos, la cual representa mi primer intento de incorporar elementos gráficos y multimedia a mis programas hechos en dbFast, en la versión 2.0D-2. Este programa es un sensillísimo ejemplo de Anuario que incluye los ejecutables y las fuentes en PRG, y aunque hay cosas por depurar (tarea que les dejo a ustedes), funciona sin problemas.

Pueden descargarlo desde MEGAUPLOAD

Acá algunas capturas del Anuario para ustedes:

Saludos y nos vemos en el próximo artículo.