Algo sobre Clipper 5.01

por Waldemar Vigo

[Números en letras][División de un texto en renglones][Lectura y grabación binaria][Preguntas de Gente Amiga][Uso del Mouse][Impresoras a Chorro de Tinta][Correo al autor]

Mi tarea es programar, específicamente en el entorno PC y más precisamente aún, con Clipper 5.01. Ante el embate de Bill Gates, la atracción del entorno gráfico, la popularidad de los sistemas operativos de 32 bits, la tendencia es dejar de lado este lenguaje por Visual Basic o algun otro afín. Sin embargo, la obsolescencia de un lenguaje de programación no tira por la borda la concepción de rutinas. Los conceptos de las rutinas pueden pasarse de un lenguaje a otros, a veces con cambios mínimos. Las que presento a continuación están destinadas a dos fines:

• La conversión de números menores de 1.000:000.000,00 (mil millones) en letras.
• La división de un texto en renglones que corten en palabras justas (Wrap).

Si Ud halla alguna otra solución o una optimización de las presentes, sería de mi agrado conocerlas.
Si Ud va a hacer uso de esta rutina en sus programas -lo cual vería yo con mucho placer- simplemente hágamelo saber por e-mail. Esto es e-mailware, es decir de libre uso, pero be polite!.

Conversión de números en texto

La rutina NTOL que convierte números en letras hace uso de matrices en memoria para almacenar las palabras que compondrán el texto final. Con un pequeño esfuerzo es posible usar archivos.dbf en lugar de esas matrices. El límite superior de mil millones es harto suficiente para la mayoría de las aplicaciones comerciales y también, con un pequeño esfuerzo, es posible ampliar este margen superior si fuere necesario.

Uso:

NTOL(nImporte) -> cImportEnLetras

nImporte es el total numérico que hay que representar con letras. El máximo es de mil millones. Si se suministra un número mayor, NTOL devuelve una cadena vacía.

cImportEnLetras es una cadena de caracteres que contiene el número expresado en letras, en idioma español.

Ejemplo:

? NTOL(2132,50) // Devuelve: "DOS MIL CIENTO TREINTA Y DOS CON 50/100"

* IMPORLET.PRG   Rutinas que convierten números con dos decimales en letras
*
********** Rutina válida para números menores de mil millones

FUNC NTOL(nNumero)
LOCAL nCentavos := (nNumero - INT(nNumero)) * 100
LOCAL cCadena := ''                         
LOCAL nMillon := 0
LOCAL nCienMil := 0

nNumero := INT(nNumero) 

IF nNumero < 1000000000   // Mil millones!!!
    IF nNumero > 999999   // es un millón o más, hasta 999 millones 
        nMillon := INT(nNumero/1000000)
        nNumero := nNumero - nMillon*1000000
        cCadena += BASE(nMillon, .T.) + IF(nMillon>1, ' MILLONES ', 'MILLON ')
    ENDIF

    IF nNumero > 999   // Son más de mil
        nCienMil := INT(nNumero/1000)
        nNumero := nNumero - nCienMil*1000
        cCadena += BASE(nCienMil, .F.) + ' MIL '
    ENDIF

    cCadena += BASE(nNumero, .T.)  

    IF .NOT.EMPTY(cCadena)
        cCadena += ' CON '
    ENDIF
    cCadena += STRZERO(nCentavos, 2) + '/100'                     
ENDIF

RETURN (STRTRAN(cCadena, '  ', ' '))

********** Se pasa el número <= 999 sin decimales

STATIC FUNC BASE(nNumero, lFin)
LOCAL cCadena := ''
LOCAL nUnidad := 0 
LOCAL nDecena := 0
LOCAL nCentena := 0

IF nNumero < 1000
    IF nNumero > 99
        nCentena := INT(nNumero/100)
        nNumero := nNumero - nCentena*100
        IF nCentena == 1 .AND. nNumero == 0
            cCadena += 'CIEN '
         ELSE
            cCadena += CENTENAS(nCentena) + ' '
        ENDIF
    ENDIF

    IF nNumero > 29
        nDecena := INT(nNumero/10)
        nNumero := nNumero - nDecena*10
        IF nNumero > 0
            cCadena += DECENAS(nDecena) + ' Y ' + UNIDAD(nNumero, F.) + ' '
         ELSE
            cCadena += DECENAS(nDecena) + ' '
        ENDIF
     ELSE
        cCadena += UNIDAD(nNumero, lFin)
    ENDIF
ENDIF

RETURN (cCadena)

********** lFin indica si debe tomarse UNO en lugar de UN

STATIC FUNC UNIDAD(nNumero, lFin)
LOCAL aUnidades := {'UN','DOS','TRES','CUATRO','CINCO','SEIS','SIETE', ;
'OCHO','NUEVE','DIEZ','ONCE','DOCE','TRECE','CATORCE', ;'QUINCE','DIECISEIS', ;
'DIECISIETE','DIECIOCHO','DIECINUEVE','VEINTE',;
'VEINTIUNO','VEINTIDOS', ;
'VEINTITRES','VEINTICUATRO','VEINTICINCO','VEINTISEIS',;
'VEINTISIETE', ;
'VEINTIOCHO','VEINTINUEVE'} 
LOCAL cCadena := ''

IF nNumero > 0
    IF nNumero == 1 .AND. lFin
        cCadena := 'UNO'
     ELSE
        cCadena := aUnidades[nNumero]
    ENDIF
ENDIF

RETURN (cCadena)

**********

STATIC FUNC DECENAS(nNumero)
LOCAL aDecenas := {'DIEZ','VEINTE','TREINTA','CUARENTA','CINCUENTA', ;
 'SESENTA','SETENTA','OCHENTA','NOVENTA'} 

RETURN (IF(nNumero==0, '', aDecenas[nNumero])) 

**********

STATIC FUNC CENTENAS(nNumero)
LOCAL aCentenas := {'CIENTO','DOSCIENTOS','TRESCIENTOS','CUATROCIENTOS', ;
 'QUINIENTOS','SEISCIENTOS','SETECIENTOS','OCHOCIENTOS','NOVECIENTOS' } 

RETURN (IF(nNumero==0, '', aCentenas[nNumero]))

Distribuir un texto en renglones

La rutina GRAPPA ha sido probada para que suministre una matriz donde cada elemento corresponde a un renglón, de modo que cada uno contenga palabras enteras, salvo que haya alguna cuyo largo sea mayor que el indicado en nCaracteres; en ese caso se trunca la palabra larga. Si hay retornos de carro intercalados -chr(13)+chr(10)- se los toma como un renglón más, en blanco.

Uso:

GRAPPA(cTexto, nCarac) -> aTexto

cTexto es la cadena de caracteres que hay que poner en renglones.

nCarac es el número de caracteres que tendrá como máximo cada renglón.

aTexto es una matriz de caracteres, donde cada elemento mide nCarac, el texto de cada renglón está recostado sobre la izquierda y está rellenado a la derecha con blancos.

********** Devuelve una matriz con elementos/renglones de nCaracteres cada uno.

FUNC GRAPPA(cCadena, nCaracteres)
LOCAL aTexto := {}
LOCAL nCont := 0
LOCAL lMuyLarga := .F.

cCadena := IF(cCadena == NIL, '', LTRIM(cCadena))
nCaracteres := IF(nCaracteres == NIL, 0, nCaracteres)

IF nCaracteres > 0
    IF LEN(cCadena) > nCaracteres
       WHILE LEN(cCadena) > 0
           WHILE chr(13)+chr(10) $ LEFT(cCadena, nCaracteres)
               IF LEFT(cCadena,2) == chr(13) + chr(10)
                   AADD(aTexto, SPACE(nCaracteres))     
               ELSE 
                   AADD(aTexto, PADR(LEFT(cCadena,AT(chr(13)+chr(10),cCadena)-1), nCaracteres))    
               ENDIF
               cCadena := SUBSTR(cCadena, AT(chr(13)+chr(10),cCadena)+2)
           ENDDO
           IF LEN(cCadena) <= nCaracteres
               AADD(aTexto, PADR(cCadena, nCaracteres))
               EXIT
           ELSE 
               IF SUBSTR(cCadena, nCaracteres, 1) == ' ' .OR. ;
                  SUBSTR(cCadena, nCaracteres+1, 1) == ' ' .OR. ;
                  SUBSTR(cCadena, nCaracteres, 1) == CHR(13) .OR. ;                  
                  SUBSTR(cCadena, nCaracteres+1, 1) == CHR(13)
                   *    El último carácter o el primero del siguiente es justo 
                   *        un espacio en blanco o un retorno de carro 
                   IF SUBSTR(cCadena, nCaracteres, 1) == CHR(13)
                       AADD(aTexto, PADR(LEFT(cCadena, nCaracteres-1), nCaracteres))                   
                       cCadena := LTRIM(SUBSTR(cCadena, nCaracteres))
                   ELSE 
                       AADD(aTexto, PADR(LEFT(cCadena, nCaracteres), nCaracteres))
                       cCadena := LTRIM(SUBSTR(cCadena, nCaracteres + 1))
                   ENDIF
               ELSE
                   nCont := nCaracteres
                   lMuyLarga := .T.
                   WHILE --nCont > 0
                       IF SUBSTR(cCadena, nCont, 1 ) == ' ' .OR. ;
                          SUBSTR(cCadena, nCont, 1 ) == CHR(13)
                           IF nCont == 1
                               IF SUBSTR(cCadena, nCont, 1) == CHR(13)
                                   AADD(aTexto, SPACE(nCaracteres))                                                    
                                   cCadena := LTRIM(SUBSTR(cCadena, 3))                                
                               ELSE 
                                   cCadena := LTRIM(SUBSTR(cCadena, 2))
                               ENDIF
                           ELSE
                               IF SUBSTR(cCadena, nCont, 1 ) == CHR(13)                               
                                   AADD(aTexto, PADR(LEFT(cCadena, nCont-1), nCaracteres))                                                
                                   cCadena := LTRIM(SUBSTR(cCadena, nCont))                           
                               ELSE  
                                   AADD(aTexto, PADR(LEFT(cCadena, nCont), nCaracteres))                 
                                   cCadena := LTRIM(SUBSTR(cCadena, nCont + 1))                               
                               ENDIF 
                               lMuyLarga := .F.
                           ENDIF
                           EXIT
                       ENDIF
                   ENDDO
                   IF lMuyLarga
                       AADD(aTexto, PADR(LEFT(cCadena, nCaracteres), nCaracteres))                
                       cCadena := LTRIM(SUBSTR(cCadena, nCaracteres + 1))
                   ENDIF
               ENDIF
           ENDIF
       ENDDO
    ELSE
       AADD(aTexto, cCadena)
    ENDIF
ELSE
    AADD(aTexto, '')
ENDIF

RETURN(aTexto)

********** 

Recortar un archivo binario

El presente código no es propiamente una rutina independiente. Por otra parte es muy específica de Clipper5.0x pero como usa funciones muy parecidas a las de C/C++ la cito por si quiere traspolarla.
Esta rutina fue desarrollada para "limpiar" un log compilado: había que eliminar la parte final del archivo sin tocar el comienzo.

nManejOut y nManejIn son los manejadores de los archivos NUEVO.LOG y VIEJO.LOG respectivamente.
Lee de a 50 caracteres (podría ser otra cantidad, pero debemos aseguramos que pueda caber la cadena buscada en ella), busca esa cadena (cConstante) y si la halla, graba los caracteres anteriores a la misma y finaliza.

cVariable debe tener 50 caracteres como mínimo, en el caso mencionado.
cVari es transitoria para no ejecutar dos veces un complejo de funciones y no escribirlas.
lBien es una variable lógica que es inicializada en .F. al crearla.
nLeidos es una variable numérica para detectar si se leyeron datos del archivo.
Por supuesto, todas las variables son locales.

IF (nManejOut := FCREATE('NUEVO.LOG')) # -1  
    IF (nManejIn := FOPEN('VIEJO.LOG')) # 0 
        WHILE .T. 
            IF (nLeidos := FREAD(nManejIn, @cVariable, 50))  > 0 
                IF cConstante $ cVariable                
                    cVari := LEFT(cVariable, AT(cConstante, cVariable)-1)
                    IF FWRITE(nManejOut, cVari, LEN(cVari)) # LEN(cVari)
                        ?'Error al grabar NUEVO.LOG'
                    ELSE
                        lBien := .T.
                    ENDIF
                    EXIT
                ELSE
                    IF FWRITE(nManejOut, cVariable, nLeidos) # nLeidos  
                        ?'Error al grabar NUEVO.LOG'
                    ENDIF
                ENDIF
            ELSE 
                EXIT 
            ENDIF 
        ENDDO 
        FCLOSE(nManejIn) 
    ENDIF  
    FCLOSE(nManejOut) 
ENDIF 

IF lBien
    FERASE('VIEJO.LOG')
    RUN COPY NUEVO.LOG VIEJO.LOG
    FERASE('NUEVO.LOG')
ENDIF

Uso del Ratón con Clipper 5.01/5.02

Aunque parezca extemporáneo, varios amigos han preguntado por una rutina que permita el uso del mouse con Clipper 5.01/5.02.

Luego de revisar muchos cajones (la verdad es que nunca hice una aplicación real que las utilizara) las pongo a vuestra disposición.

Las rutinas siguientes fueron suministradas por el maestro Gustavo Gretter.

Sería de buena educación, en caso de usarlas, enviarle un e-mail agradeciéndoselo.

include macros.mac

CODE SEGMENT
ASSUME CS:CODE

public ResetMouse
public MouseOn
public MouseOff
public GetMouseX
public GetMouseY
public GetLeft
public GetRight
;
ResetMouse PROC FAR

        xor      ax,ax
        int      33h
        ret

ResetMouse ENDP
;
MouseOn PROC FAR

        mov      ax,1
        int      33h
        ret

MouseOn ENDP
;
MouseOff PROC FAR

        mov      ax,2
        int      33h
        ret

MouseOff ENDP
;
GetMouseX PROC FAR

        mov       ax,3
        int       33h
        push      cx
        call      __retni
        add       sp,2
        ret

GetMouseX ENDP
;
GetMouseY PROC FAR

        mov       ax,3
        int       33h
        push      dx
        call      __retni
        add       sp,2
        ret

GetMouseY ENDP
;
GetLeft PROC FAR

        mov        ax,3
        int        33h
        and        bx,1
        push       bx
        call       __retni
        add        sp,2
        ret

GetLeft ENDP
;
GetRight PROC FAR

        mov        ax,3
        int        33h
        and        bx,2
        push       bx
        call       __retni
        add        sp,2
        ret

GetRight ENDP
;
CODE ENDS
END

Una vez compiladas (puede ser con MASM5), se obtendrá el .OBJ que luego será linkeditado con el fuente.PRG que hayan construido y serán invocadas así:

cls
MouseOn()
WHILE .T.
  @ 10,10 SAY GetMouseX()/8 
  @ 11,10 SAY GetMOuseY()/8
  IF GetLeft()!=0
      ? chr(7)
  ENDIF
  IF GetRight()!=0
      ? chr(7)
      ? chr(7)
  ENDIF
ENDDO
MouseOff()

Caracteres de Control a Impresoras de Chorro de Tinta

Cayó en nuestras manos, luego de ingentes esfuerzos, unas tablas de caracteres de control que deben enviarse a las impresoras de Chorro de tinta para que acepten compresión, letra cursiva, etc. pudiéndose aplicar desde una rutina DOS incluso.

Como el texto es muy largo irá apareciendo de a poco, a medida que el ánimo me contagie.

Comandos de Impresoras HP DeskJet 6xx y 8xx Series

Este documento lista los comandos de impresora HP DEskJet PCL para formato básico de página y selección de fuentes. Si necesita más información acerca de los comandos PCL, por favor use el Manual de Referencia Técnica (part number 2170-90099).

Puede usar la siguiente tabla para convertir valores ASCII a valores decimales o hexadecimales:

Códigos de control HP PCL

El código de control es un cáracter que inicia una función de la impresora. Para generar CTRL, presione la tecla de control en el teclado de la computadora al escribir el carácter. Esta tecla podría rotularse: CTRL, CNTL o CTL. La siguiente tabla enumera los códigos HP PCL que la impresora reconoce. La columna "Pulsación" indica la letra que deben presionarse con la tecla CTRL para enviar un código de control. La posición "Posición actual de impresión" en la columna "Descripción" es la posición donde la impresora imrpime el siguiente carácter.

Especificaciones

Por más información sobre PCL Printer Commands ... haga una búsqueda en www.google.com o www.altavista.com con "PCL Printer Commands" ... y suerte!
Por si no encuentra nada, aquí hay algunos sitios con indicaciones pertinentes:
http://www.hp.com/cposupport/printers/support_doc/bpl02705.html
http://web.1asphost.com/agostinho/kb/content_by_cat.asp?catid=104
http://rabbit.eng.miami.edu/info/hp-pcl.html
http://techref.massmind.org/techref/language/pcls.htm

[Números en letras][División de un texto en renglones][Lectura y grabación binaria][Preguntas de Gente Amiga][Uso del Mouse][Impresoras a Chorro de Tinta][Correo al autor]