Mostrando las entradas con la etiqueta Utilidades. Mostrar todas las entradas
Mostrando las entradas con la etiqueta Utilidades. Mostrar todas las entradas

3 de febrero de 2021

Ahora Stonefield Database Toolkit es de código abierto

Doug Hennig dicidió liberar el código de su herramienta Stonefield Database Toolkit (SDT).

La versión de código abierto de SDT está disponible en https://github.com/DougHennig/StonefieldDatabaseToolkit

La descarga incluye todo el código fuente, la documentación (como un archivo de ayuda CHM, incluyendo la fuente del generador de ayuda HTML de West Wind) y archivos de tutoriales. Todo para poder disfrutar de ésta herramirenta

A continuación una traducción libre al español de la introducción del archivo de ayuda de Stonefield Database Toolkit.


Bienvenido a Stonefield Database Toolkit (SDT)

Stonefield Database Toolkit (SDT) es una poderosa herramienta escrita por Doug Hennig y comercializada durante más de dos décadas por Stonefield Software Inc. Desde el mes de enero, Stonefield Software liberó el código de SDT, poniéndolo a disposición en forma gratuita, para todos los desarrolladores de Visual FoxPro.

SDT proporciona herramientas de administración de bases de datos a los desarrolladores, para ayudar tanto durante el desarrollo de aplicaciones como en tiempo de ejecución.

Hay tres aspectos de Stonefield Database Toolkit:

  • Mejora las herramientas que proporciona VFP para administrar objetos de datos.
  • Proporciona la capacidad de definir propiedades extendidas para objetos de base de datos y establecer u obtener los valores de estas propiedades en tiempo de ejecución.
  • Incluye una biblioteca de clases que puede agregar a sus aplicaciones para proporcionar funciones de administración de datos en tiempo de ejecución, incluida la recreación de índices, la reparación de encabezados de notas y tablas dañados y la creación y actualización de estructuras de tablas en los sitios de los clientes.

Al usar SDT, obtendrá los siguientes beneficios:

  • Reducción del tiempo de desarrollo: ¿Por qué reinventar la rueda? Las rutinas basadas en datos incluidas con SDT le liberan de escribir muchas de las rutinas de mantenimiento de tablas que exigen los usuarios sofisticados de hoy. Las rutinas basadas en datos escritas una vez se pueden incluir en cada aplicación que desarrolle sin modificaciones. Simplemente agréguelos al proyecto, llámelos desde algún lugar (un menú, un formulario o un programa) y olvídese de ellos.
  • Esfuerzo de mantenimiento reducido: el término "basado en datos" significa que el diccionario de datos controla la aplicación. Cambie el diccionario de datos y muchos aspectos de la aplicación se ajustarán automáticamente sin programación.
  • Documentación automática: El Asistente de documentación, que se incluye con Visual FoxPro, documenta los archivos de su aplicación, pero está limitado en la documentación de sus datos. SDT puede producir automáticamente documentación de alta calidad, describiendo completamente sus tablas y vistas, sus campos, índices y propiedades extendidas.

SDT viene con código fuente completo. Puede instalarse en cualquier carpeta de su computadora o red. Nota: si una versión anterior de SDT está instalada en su computadora, es posible que desee instalar esta versión en una carpeta diferente para evitar sobrescribir la versión anterior.

Encontrará dos subcarpetas en la carpeta donde instaló los archivos:

  • SDT: los archivos específicos de SDT.
  • SFCOMMON: los archivos comunes utilizados por todos los productos Stonefield.

La subcarpeta SDT contiene los siguientes archivos:

  • REINDEX.PRG, REPAIR.PRG y UPDATE.PRG: contenedores para los métodos SDT Reindex(), Repair() y Update(). Consulte el capítulo Tutorial para obtener mas información sobre el uso de estos programas.
  • SDT.APP, SDT.PJX y SDT.PJT: la aplicación de desarrollo SDT y los archivos del proyecto que la crean.
  • SDT.CHM: el archivo de ayuda de SDT.
  • Además de estos archivos, encontrará cinco subcarpetas mas en la subcarpeta SDT:

    • DBCX: proporciona documentación para DBCX.
    • HTMLHELP: la fuente para SDT.CHM usando el generador de ayuda HTML de West Wind.
    • SOURCE: código fuente de la aplicación principal (SDT.APP) y las bibliotecas de clases visuales que incluirás en tus aplicaciones.
    • TUTORIAL: archivos para el tutorial SDT.
    • UTILITY: programas de utilidades y archivos de apoyo. Consulte la sección Funciones de utilidades en SDT.CHM para obtener mas información sobre estas utilidades.

    Nota: Todo el código fuente que viene con SDT se compiló en Visual FoxPro 9. Si usa una versión anterior de Visual FoxPro, debe volver a compilar todos los archivos. La forma más sencilla de hacer esto es abrir el proyecto SDT en la carpeta SDT, hacer clic en el botón Generar, y marcar la opción Recompilar todos los archivos y elegir Reconstruir proyecto.


    2 de mayo de 2018

    Convertir a minúsculas

    Cuatro formas que podemos utilizar a la hora de capturar texto que requieren solo minúsculas.

    Ocasiones las hay en las que requerimos el uso de cuadros de texto que acepten solo letras minúsculas, por ejemplo los casos concretos de correos electrónicos y sitios web.

    1. Utilizando la función LOWER() que convierte el texto a minúsculas, para ello agregamos lo siguiente al método LOSTFOCUS del cuadro de texto:

    * - Convierte todo el contenido a minúsculas
    This.Value=LOWER(This.Value)

    Lo anterior con el inconveniente de no simular que se reciben solo minúsculas.

    2. La propiedad InputMask. A partir de la versión 9.0 de VFP se agrega el valor 'W' el cual permite carcateres alfabéticos y los convierte a minúsculas.

    Véase: Nuevos valores para InputMask y Format en VFP 9.0 esta con el inconveniente de que al solo aceptar caracteres alfabéticos no permite la captura de la @ (arroba).

    2. Utilizar la función CAPSLOCK() la cual nos regresa el estado de la tecla con el mismo nombre y además de la posibilidad de cambiarlo.

    En el método Init de un formulario declaramos:

    PUBLIC lCapsLock

    En el método GOTFOCUS de un cuadro de texto agregamos:

    * - Guardamos el estado de la tecla
    lCapsLock=CAPSLOCK()
    * - Lo turnamos a off
    CAPSLOCK(.F.)

    Con esto solo se aceptarán minúsculas incluyendo el caracter @ (arroba).

    En el método LOSTFOCUS del cuadro de texto agregamos:

    * - Restauramos la condición de la tecla
    CAPSLOCK(lCapsLock)

    Lo anterior con la posibilidad de que el Usuario presione nuevamente la tecla CapsLock y provoque que el cuadro de texto admita solo mayúsculas. Para asesurarnos podemos agregar al mismo método lo visto en el punto número 1:

    * - Convierte todo el contenido a minúsculas
    This.Value=LOWER(This.Value)

    4. Utilizar el método KeyPress del cuadro de texto para convertir cada mayúscula tecla presionada a minúscula:

    LPARAMETERS nKeyCode, nShiftAltCtrl
    IF BETWEEN(nKeyCode,65,90)
      NODEFAULT 
      cMinuscula="'{"+TRANSFORM(nKeyCode+32)+"}'"
      KEYBOARD &cMinuscula
    ENDIF 

    Lo anterior permite simular que solo se reciben minúsculas sin limitar los caracteres a ingresar.

    Saludos.

    Jesus Caro V

    31 de marzo de 2018

    EditSource()

    La nueva función EditSource() en VFP7 y superior es particularmente práctica en por lo menos 3 escenarios.

    1) Comunicandose con otro desarrollador con respecto a un código en una localización particular de un método o PRG. Por ejemplo, al reportar un "bug" al desarrollador, en lugar de escribir algo parecido a esto al describir donde está el problema:

    MODI CLASS AlgunaClase OF AlgunVCX METHOD AlgunMetodo
    *-- ir a la línea 17
    *-- or 
    *-- ir a la línea IF VARTYPE(AlgunaVariable) = 'U'
    

    Ud. solo puede escribir:

    EditSource("AlgunVCX.VCX",17,"AlgunaClase","AlgunMetodo")
    

    y a continuación describir el problema.

    2) Escribir a un desarrollador que abra el programa, clase, o formulario en una línea específica del código.

    3) Insertando referencias de EditSource() en comentarios de código, así que cualquier lectura del desarrollador, puede simplemente seleccionar el texto del EditSource() y hacer Click Derecho y ejecutar la selección desde el menú contextual.

    Clases:

    EditSource("MyLib.VCX",0,"ClassName")
    

    ... equivalente a MODI CLASS ClassName OF MyLib

    Métodos de clases:

    EditSource("MyLib.VCX",2,"ClassName","Init")
    

    ... equivalente a MODI CLASS ClassName OF MyLib METHOD INIT, pero con la ayuda agregada de especificar el número de la línea donde se coloca el cursor.

    Métodos de clases miembros:

    EditSource("MyLib.VCX",2,"ClassName","Member.Init")
    

    ... equivalente a MODI CLASS ClassName OF MyLib METHOD Member.Init, pero con la ayuda agregada de especificar el número de la línea donde se coloca el cursor.

    Formularios

    EditSource("MyForm.SCX")
    

    ... equivalente a MODI FORM MyForm

    Métodos de formularios:

    EditSource("MyForm.SCX",6,"","Form1.Load")
    

    ... equivalente a MODI FORM MyForm METHOD LOAD, pero con la ayuda agregada de especificar el número de la línea donde se coloca el cursor.

    Metodos miembros de formularios:

    EditSource("MyForm.SCX",13,"","Form1.Member.Init")
    

    ... equivalente a MODI FORM MyForm METHOD Member.Init, pero con la ayuda agregada de especificar el número de la línea donde se coloca el cursor.

    Programas:

    EditSource("MyPRG.PRG")

    ... equivalente a MODI COMM MyPRG

    Programas:

    EditSource("MyPRG.PRG",10)

    ... equivalente a MODI COMM MyPRG, pero con la ayuda agregada de especificar el número de la línea donde se coloca el cursor.

    Como el número exacto de la línea puede cambiar, al llamar EditSource() desde el código de un desarrollador que cambio el código fuente por modificaciones o la inserción de comentarios, usted puede determinar programaticamente el número de la línea deseada antes de llamar EditSource(). Ud. puede usar un PRG como el ejemplo:

    local laLines[1], lnLine, xx
    alines(laLines,filetostr("Test.PRG"))
    FOR xx = 1 to alen(laLines,1)
      IF laLines[xx] = 
        lnLine = xx
        exit
      ENDIF
    ENDFOR
    EditSource("Test.PRG",lnLine)

    EditSource() dispara un NOWAIT implícito de modo que usted pueda tomar la acción de seguimiento en el código del desarrollador que ejecuta EditSource(). Por ejemplo, para destacar una línea específica del código, ejecute:

    keyboard "{Shift+End}" 

    ó

    keyboard "{Shift+DnArrow}"

    inmediatamente después del comando EditSource().

    Copie y pegue el código siguiente en la ventana de comandos, y después lo ejecuta para ver el efecto:

    text to lcString noshow
    * test.prg
    aa = 100
    bb = 200
    cc = 300
    return aa + bb + cc
    endtext
    strtofile(lcString,"test.prg")
    text to lcString noshow
    * test1.prg
    editsource("test.prg",3)
    keyboard "{Shift+DnArrow}"
    endtext
    strtofile(lcString,"test1.prg")
    do test1

    [025] VFP Tips & Tricks - Drew Speedie

    15 de enero de 2017

    Unir archivos PDF (Merge PDFs) mediante Ghostscript

    A veces se requiere unir varios archivos PDF en un solo archivo, esto es posible mediante algunos software de manera manual, sin embargo es necesario establecerlo de manera automática para los usuarios. Después de probar varias alternativas quede con las siguientes líneas, lo cual es lo básico, ustedes podrán explotarles más opciones.

    La solución de la herramienta Ghostscript es posible. Esta solución está disponible para 32Btis y 64Bits. En este ejemplo utilizaremos la de 64, mediante el archivo gswin64c.exe

    folderactual = Sys(5) + Curdir()
    
    * Armanos el BAT que lanzara el Script Merge
    TEXT TO cComando TEXTMERGE NOSHOW PRETEXT 15
    <<m.folderactual>>bin\gswin64c.exe -dBATCH -dNOPAUSE -dCompatibilityLevel=1.4 -sDEVICE=pdfwrite -sOutputFile="merge.pdf" "pdf1.pdf" "pdf2.pdf" "pdf3.pdf"
    ENDTEXT
    
    cArchivo = folderactual + 'Merge.bat'
    
    * Creamos el archivo BAT
    Strtofile(cComando, cArchivo)
    
    * Ejecutamos el archivo BAT
    oShell = Createobject("WScript.Shell")
    oShell.Run(cArchivo,0,.T.)
    Messagebox('Proceso de fusión realizado por éxito!',64,"")
    
    * Abrimos el Archivo fusionado
    cArchivo = folderactual + 'Merge.pdf'
    oShell.Run(cArchivo,0,.T.)
    
    *--- Eliminamos el archivo backup.bat
    Delete File folderactual + 'Merge.b
    

    Descarga el proyecto de ejemplo: Merge_PDF.rar

    Enlaces:

    https://es.wikipedia.org/wiki/Ghostscript
    https://ghostscript.com/download/gsdnld.html

    Nota: Descargar Ghostscript AGPL Release e instalarlo en la PC usuario

    Lic. Allan Raul Acuña
    Analista Programador
    Managua, Nicaragua

    21 de octubre de 2016

    Desglosar cadenas separadas por comas en matrices de Visual FoxPro

    Artículo original: Parsing comma-delimited strings into a Visual Foxpro array
    http://www.ml-consult.co.uk/foxst-15.htm  
    Autor: Mike Lewis
    Traducido por: Ana María Bisbé York


    Un modo sencillo de desglosar datos en una cadena separada por comas.

    En Visual FoxPro (y otros lenguajes de programación) las cadenas delimitadas por comas son una vía sencilla para guardar pequeñas colecciones de datos. Es habitual el uso de estas cadenas para pasar parámetros a procedimientos o funciones, o para guardar valores en propiedades de usuarios o clases. Puede además, importar datos de algunas aplicaciones en forma de un archivo de texto delimitado por comas.

    He aquí una vía sencilla para desglosar una cadena separada por comas en VFP 6.0. Utilizando esta sencilla línea de código, puede extraer rápidamente cada elemento separado por la coma y colocarlo en un elemento independiente de la matriz.

    nRows = ALINES(laData, STRTRAN(cTest,",",CHR(13)))

    En este caso, la cadena delimitada por comas se llama cTest y la matriz se llama laData. Si no existe la matriz, la crea. Luego de ejecutar el código, la variable nRows contendrá la cantidad de elementos en la matriz.

    El código realiza dos sencillas operaciones. Primero, la función STRTRAN() convierte cada una de las comas en un carácter de fin de cadena (ASCII 13). La función ALINES() coloca cada "línea" que se ha formado en un elemento de la matriz. ALINES(), que se introdujo en VFP 6.0, está diseñada para extraer párrafos de cadenas de texto muy largas; pero funciona también en el contexto mostrado aquí.

    En VFP 7.0 y superior, el código es incluso más sencillo. VFP 7.0 introdujo un parámetro adicional a ALINES(), el que le permite especificar un carácter fin de línea personalizado. Entonces, en lugar de tener que utilizar STRTRAN() para convertir las comas en ASCII 13, puede sencillamente estipular que la coma marca el fin de línea. El código entonces, es el siguiente:

    nRows = ALINES(laData, cTest, .F., ",")

    El tercer parámetro de ALINES() es un indicador que dice si la "línea" debe ser recortada cuando es copiada en la matriz.

    Si desea convertir un archivo de texto entero en una matriz simplemente conviértalo en una cadena de caracteres antes con el código que se muestra a continuación. En VFP 6.0 y superior, la forma más fácil de convertir un archivo en una cadena es con la función FILETOSTR(). Entonces, teniendo un archivo de texto delimitado por comas llamado CLIENTS.TXT, he aquí cómo lo puede desglosar en una matriz llamada aClients:

    cClients = FILETOSTR("clients.txt")
    nRows = ALINES(aClients,STRTRAN(cClients,",",CHR(13)))

    Vea que esta técnica no trabaja si las variables como tal contienen comas. Cuando se almacenan, por ejemplo, nombres y direcciones como variables separadas por comas, por ejemplo, lo habitual es encerrarlas entre comillas, para indicar que al desglosar trate todo este texto entre comillas como un único elemento. Desafortunadamente el código mostrado en este artículo no puede controlar esta situación.

    Mike Lewis Consultants Ltd. Julio 2000. Revisado Noviembre 2001.

    9 de mayo de 2016

    Un gran selector de Color

    Artículo original: A great Color Picker
    http://weblogs.foxite.com/vfpimaging/archive/2008/01/17/5556.aspx
    Autor: VFPIMAGING
    Traducido por: Luis María Guayán


    Recientemente el MVP Cetin Basoz envio un gran script que genera un excelente selector de color. Es tan bueno y útil, que lo añadí a mi menú de "Herramientas" de desarrollo.

    ¡Gracias Cetin!

    Si está interesado, puede descargarlo de aquí: mousetracker.zip 1,16 KB


    30 de abril de 2016

    Actualizar aplicaciones

    Permite actualizar la Aplicacion tanto en el equipo local como actualizar el servidor donde esta la aplicacion a distribuir.

    Poner este codigo en archivo de inicio principal (prg).

    Luego de Generar nuestro ejecutable, el instalador ademas de todos los archivos necesarios, tiene que instalar en cada maquina el Archivo ACTUALIZA.BAT y/o UPLOAD.BAT

    El Archivo Upload.bat es identico al Actualiza solo cambia la direccion de la copia.

    ***** Comprueba Nueva Version  *******
    
    AGETFILEVERSION(ServerApp,"\\miservidor")
    Version_Mayor = VAL(SUBSTR(ServerApp(4),1,1))
    Version_Menor = VAL(SUBSTR(ServerApp(4),3,AT(ServerApp(4),".",1) + 1))
    Version_Mantension = VAL(SUBSTR(ServerApp(4),5,2) )
    
    AGETFILEVERSION(MiApp,"C:\Archivos de programa\CDP\CDP.exe")
    MiVersion_Mayor = VAL(SUBSTR(miapp(4),1,1))
    MiVersion_Menor = VAL(SUBSTR(miapp(4),3,AT(miapp(4),".",1) + 1))
    MiVersion_Mantension = VAL(SUBSTR(miapp(4),5,2) )
    *
    IF !(MiVersion_Mayor = Version_Mayor.AND.MiVersion_Menor = Version_Menor ;
    .AND.MiVersion_Mantension = Version_Mantension)
      **** Actualizar
      ** Si soy yo copia al servidor
      IF UPPER(ALLTRIM(SUBSTR(SYS(0),AT("#",SYS(0),1) + 1,LEN(SYS(0))))) = "miUsername"
        MESSAGEBOX("Las Versiones Son: ServerApp -> " + ServerApp(4) + CHR(13) + ;
          "Local App. ->" + miApp(4) + CHR(13) + "Actualizando el Servidor")
    
        RUN /N "C:\Archivos de programa\CDP\UPLOAD.BAT"
      ELSE
    
        SET DEFAULT TO "C:\Archivos de programa\CDP"
        RUN /N "ACTUALIZA.BAT"
        QUIT
      ENDIF
    ENDIF
    
    ***** Fin Comprobacion de Actualizacion
    
    Contenido del archivo ACTUALIZA.BAT
    
    @ECHO OFF
    @ECHO Actualizando Sistema xxxxxxx
    @ECHO AUTOR.: Ludwig Corales M.
    @ECHO Actualizado al : %DATE%
    @xCopy \\soft\CDP.EXE "C:\Archivos de programa\CDP" /C /R /Y
    
    ***** Fin Contenido **********
    
    ***** Contenido del archivo UPLOAD.BAT ******
    
    @ECHO OFF
    @ECHO Actualizando Sistema xxxxxxx
    @ECHO AUTOR.: Ludwig Corales M.
    @ECHO Actualizado al Servidor : %DATE%
    @xCopy "C:\Archivos de programa\CDP\CDP.exe" \\soft\  /C /R /Y
    
    ***** Fin Contenido **********

    Notar que se comparan siempre tanto las versiones mayores, menores y sub versiones, para ver si se actualiza o no.

    Atte.

    Ludwig Corales Marti

    22 de marzo de 2016

    Detectar inactividad

    Pueden utilizar la siguiente función para detectar un período de inactividad, ya sea en todo Windows o solamente en la aplicación.

    CLEAR
    PUBLIC tmrCheck
    tmrCheck = NEWOBJECT("DetectActivity")
    RETURN
    
    DEFINE CLASS DetectActivity as Timer
      * Sólo detecta inactividad mientras está en este programa?
      JustInThisApp = .T.
      * Intervalo de inactividad tras el cual dispara OnInactivity (en segundos)
      InactivityInterval = 5
      * Intervalo cada el que chequea actividad
      Interval = 1000
      LastCursorPos = ""
      LastKeybState = ""
      LastActivity = DATETIME()
      CursorPos = ""
      KeybState = ""
      IgnoreNext = .T.
    
      PROCEDURE Init
        DECLARE INTEGER GetKeyboardState IN WIN32API STRING @ sStatus
        DECLARE INTEGER GetCursorPos IN WIN32API STRING @ sPos
        DECLARE INTEGER GetForegroundWindow IN WIN32API
      ENDPROC
    
      PROCEDURE Destroy
        CLEAR DLLS GetKeyboardState, GetCursorPos, GetForegroundWindow
      ENDPROC
    
      PROCEDURE Timer
        WITH This
          IF ! .CheckActivity()
            * Si no hubo actividad veo si es tiempo de disparar OnInactivity
            IF ! ISNULL(.LastActivity) AND ;
                DATETIME() - .LastActivity > .InactivityInterval
              .LastActivity = NULL && Prevengo disparo múltiple de OnInactivity
              .OnInactivity()
            ENDIF
          ENDIF
        ENDWITH
      ENDPROC
    
      * Chequeo si hay actividad
      PROCEDURE CheckActivity
        LOCAL lRet
        WITH This
          IF .JustInThisApp
            IF GetForegroundWindow() <> _VFP.hWnd
              * Estoy en otro programa
              RETURN lRet
            ENDIF
          ENDIF
          .GetCurState()
          IF (!.CursorPos == .LastCursorPos OR !.KeybState == .LastKeybState)
            IF ! .IgnoreNext && La 1ra vez no ejecuto
              lRet = .T. && Hubo actividad
              .OnActivity()
              .LastActivity = DATETIME()
            ELSE
              .IgnoreNext = .F.
            ENDIF
            .LastCursorPos = .CursorPos
            .LastKeybState = .KeybState
          ENDIF
        ENDWITH
        RETURN lRet
      ENDPROC
    
      * Devuelve el estado actual
      PROCEDURE GetCurState
        LOCAL sPos, sState
        WITH This
          sPos = SPACE(8)
          sState = SPACE(256)
          GetCursorPos (@sPos)
          GetKeyboardState (@sState)
          .CursorPos = sPos
          .KeybState = sState
        ENDWITH
      ENDPROC
    
      PROCEDURE OnInactivity
        WAIT WINDOW "Inactividad a las " + TIME() NOWAIT
      ENDPROC
    
      * Hubo actividad
      PROCEDURE OnActivity
        WAIT WINDOW "Actividad a las " + TIME() NOWAIT
      ENDPROC
    ENDDEFINE

    Mario Lopez

    9 de febrero de 2016

    Desglose de billetes y monedas

    Esta utilidad sirve para determinar la cantidad de billetes y monedas para el pago de salarios.

    Partimos de dos tablas:

    1. Una tabla con la denominación y el valor de los billetes y monedas disponibles. Esta tabla puede variar de acuerdo a los billetes y monedas disponibles en cada país o en el momento de efectuar el pago.

    2. Una tabla con el listado de los nombres ó legajos y el importe a percibir.

    Al principio del siguiente código se crean las dos tablas: "Cambio" con los valores disponibles, y "Sueldos" con los legajos e importes aleatorios.

    Luego se recorre la tabla "Cambio" ordenada por el campo Valor en forma descendente (esto es premisa fundamental para el cálculo) y se crea una sentencia SELECT ... por cada valor, que añade una nueva columna por cada ciclo.
    *-- Creo tabla de Billetes y Monedas disponibles
    CREATE TABLE Cambio (Codigo C(8), Valor N(10,2))
    INDEX ON Valor TAG Valor Descending
    INSERT INTO Cambio (Codigo, Valor) VALUES ("B_100", 100)
    INSERT INTO Cambio (Codigo, Valor) VALUES ("B_50", 50)
    INSERT INTO Cambio (Codigo, Valor) VALUES ("B_20", 20)
    INSERT INTO Cambio (Codigo, Valor) VALUES ("B_10", 10)
    INSERT INTO Cambio (Codigo, Valor) VALUES ("B_5", 5)
    INSERT INTO Cambio (Codigo, Valor) VALUES ("B_2", 2)
    INSERT INTO Cambio (Codigo, Valor) VALUES ("M_1", 1)
    INSERT INTO Cambio (Codigo, Valor) VALUES ("M_050", 0.50)
    INSERT INTO Cambio (Codigo, Valor) VALUES ("M_025", 0.25)
    INSERT INTO Cambio (Codigo, Valor) VALUES ("M_010", 0.10)
    INSERT INTO Cambio (Codigo, Valor) VALUES ("M_005", 0.05)
    INSERT INTO Cambio (Codigo, Valor) VALUES ("M_001", 0.01)
    
    *-- Creo tabla de Sueldos (Salarios)
    LOCAL ln
    CREATE TABLE Sueldos (Legajo C(6), Importe N(12,2))
    FOR ln = 1010 TO 1500 STEP 10
     INSERT INTO Sueldos (Legajo, Importe) VALUES (PADL(ln,6,"0"), RAND()*5000)
    ENDFOR
    
    *-- Begin
    LOCAL lcSetPoint, llPrimeraVez, lcDeno, lcVal, lcSQL
     
    lcSetPoint = SET("POINT")
    llPrimeraVez = .T.
    lcDeno = ""
    lcVal = ""
    
    *-- Creo cursor de resultados
    SELECT Legajo, Importe FROM Sueldos INTO CURSOR Result
    
    *-- Recorro tabla de Cambio
    SET POINT TO "."
    SELECT Cambio
    SCAN ALL
      IF llPrimeraVez
        SELECT Legajo, Importe FROM Result INTO CURSOR Auxi
      ELSE
        lcSQL = [SELECT Result.Legajo, Auxi.Importe - ] + ;
          lcDeno + [*] + lcVal + [ AS Importe ] + ;
          [FROM Result ] + ;
          [INNER JOIN Auxi ON Result.Legajo = Auxi.Legajo ] + ;
          [INTO CURSOR Auxi]
        &lcSQL
      ENDIF
      lcSQL = [SELECT Result.*, ] + ;
        [INT(Auxi.Importe/] + ALLTRIM(STR(Cambio.Valor,10,2)) + ;
        [) AS ] + ALLTRIM(Cambio.Codigo) + ;
        [ FROM Result ] + ;
        [INNER JOIN Auxi ON Result.Legajo = Auxi.Legajo ] + ;
        [INTO CURSOR Result]
      &lcSQL
      lcDeno = ALLTRIM(Cambio.Codigo)
      lcVal = ALLTRIM(STR(Cambio.Valor,10,2))
      llPrimeraVez = .F.
    ENDSCAN
    SET POINT TO (lcSetPoint)
    
    *-- Muestro cursor final de resultados
    SELECT Result
    BROWSE  
    
    *-- End
    Luis María Guayán

    24 de mayo de 2015

    Métodos abreviados del teclado en VFP

    Visual FoxPro permite utilizar métodos abreviados del teclado en las áreas siguientes:
    • Comandos del menú
    • Manipulación de ventanas
    • Ayuda
    • Ventana Propiedades
    • Definiciones de macros predefinidas
    • Examinador de clases
    • Editor
    • Diseñador de informes
    • Ventana Vista preliminar

    Comandos del menú

    Método abreviado Comando
    CTRL+A Seleccionar todo (menú Edición)
    CTRL+C Copiar (menú Edición)
    CTRL+D Ejecutar (menú Programa)
    CTRL+E Eliminar elemento (menú Menú)
    CTRL+E Ejecutar (menú Programa)

    Ejecutar formulario (menú Formulario)

    CTRL+F Buscar (menú Edición)
    CTRL+G Buscar siguiente (menú Edición)
    CTRL+H Cambiar particiones (menú Tabla)
    CTRL+I Insertar elemento (menú Menú)
    CTRL+J Información del proyecto (menú Proyecto)
    CTRL+L Reemplazar (menú Edición)
    CTRL+M Reanudar (menú Programa)
    CTRL+N Nuevo (menú Archivo)
    CTRL+O Abrir (menú Archivo)
    CTRL+P Imprimir (menú Archivo)
    CTRL+Q Ejecutar consulta (menú Consulta) Salir (menú Archivo)
    CTRL+R Rehacer (menú Edición)
    CTRL+S Guardar (menú Archivo)
    CTRL+T Alternar marca de eliminación (menú Tabla)
    CTRL+V Pegar (menú Edición)
    CTRL+W Cierra la ventana de Texto actual o el cuadro de diálogo y guarda los cambios.
    CTRL+X Cortar (menú Edición)
    CTRL+Y Agregar nuevo registro (menú Tabla)
    CTRL+Z Deshacer (menú Edición)

    Manipulación de ventanas

    Método abreviado Acción
    CTRL+F1 Recorre las ventanas
    CTRL+F2 Muestra la ventana Comandos
    CTRL+F4 Cierra la ventana activa
    CTRL+F6 Recorre las ventanas
    CTRL+ALT+MAYÚS Oculta todas las ventanas secundarias mientras las teclas están presionadas. Ocultar las ventanas hace más fácil ver la salida que se presenta en la ventana principal de la aplicación.
    CTRL+F10 Alterna el tamaño de la ventana entre maximizar y restaurar.

    Ayuda

    Método abreviado Acción
    F1 Muestra el Índice de la Ayuda o Ayuda interactiva sobre elementos activos (por ejemplo, una palabra clave resaltada en la ventana Comandos o la propiedad actual de la ventana de Propiedades).
    MAYÚS+F1 Activa la Ayuda interactiva solicitada por el usuario. El puntero de inserción cambia a un signo de interrogación de forma que se puede hacer clic en un elemento (por ejemplo, un comando de menú o una barra de herramientas) para mostrar Ayuda interactiva.

    Ventana Propiedades

    Método abreviado Acción
    CTRL+ALT+letra Selecciona la siguiente propiedad en la lista de propiedades que comienza con el carácter de letra. Por ejemplo, presionar CTRL+ALT+B selecciona la próxima propiedad que comience por B.
    CTRL+AV PÁG Se desplaza al siguiente objeto de la lista desplegable Objeto.
    CTRL+RE PÁG Se desplaza al objeto anterior de la lista desplegable Objeto.
    CTRL+FIN Se desplaza al último objeto de la lista desplegable Objeto.
    CTRL+INICIO Se desplaza al primer objeto de la lista desplegable Objeto.
    Para etiquetas:
    CTRL+E
    ESC

    Cambia del modo Seleccionar a Modificar
    Cambia del modo Modificar a Seleccionar

    Definiciones de macros predefinidas

    Método abreviado Comando
    F2 SET
    F3 LIST
    F4 DIRECTORY( )(Función)
    F5 DISPLAY STRUCTURE
    F6 DISPLAY STATUS
    F7 DISPLAY MEMORY
    F8 DISPLAY
    F9 APPEND
    Nota: Las definiciones de macro se aplican a la ventana Comandos. Se pueden cambiar las definiciones de macro con el comando Macros del menú Herramientas.

    Examinador de clases

    Método abreviado Acción
    F5 Actualiza la vista actual.
    MAYÚS+F10 Muestra un menú contextual.
    Clic en el botón secundario+botón Abrir
    Clic en el botón secundario+botón Agregar
    Clic en el botón secundario+botón Galería de componentes
    Muestra el historial de los últimos 32 archivos cargados.
    Clic en el botón secundario+botón Ver código de clase Muestra el código de clase en un formulario webview.
    Ctrl+clic en el botón secundario + icono Clase
    (en la esquina superior izquierda del Examinador de clases)
    Crea una instancia de la clase con la función NEWOBJECT( ) en la ventana Comandos.

    Es idéntico a arrastrar el icono Clase a la ventana Comandos.

    MAYÚS+clic en el botón secundario+icono Clase
    (en la esquina superior izquierda del Examinador de clases)
    Para formularios, ejecuta el formulario.

    Para otros controles y objetos, crea una instancia del control u objeto. Para controles, también agrega el control al escritorio de Visual FoxPro en la posición 0,0.

    Es idéntico a arrastrar el icono Clase al escritorio de Visual FoxPro.

    Editor

    Método abreviado Acción
    CTRL+J IntelliSense, activa mostrar miembros
    CTRL+I IntelliSense – muestra información
    CTRL+J IntelliSense – activa Mostrar valores
    F3 Busca la siguiente aparición del texto especificado
    MAYÚS+F3 Busca la anterior aparición del texto especificado
    CTRL+F3, CTRL+G Busca la siguiente aparición del texto seleccionado
    CTRL+MAYÚS+F3 Busca la anterior aparición del texto seleccionado
    CTRL+FLECHA ARRIBA Desplaza la ventana hacia abajo sin mover el cursor
    CTRL+FLECHA ABAJO Desplaza la ventana hacia arriba sin mover el cursor
    CTRL+FLECHA DERECHA Mejora el desplazamiento en el editor
    CTRL+FLECHA IZQUIERDA Mejora el desplazamiento en el editor
    CTRL+F9 Activa o desactiva un punto de interrupción
    F9 Inserta o quita un punto de interrupción
    CTRL+B Abre el cuadro de diálogo Puntos de interrupción
    F2 Se desplaza a la línea que contiene el siguiente marcador
    MAYÚS+F2 Se desplaza a la línea que contiene el marcador anterior
    ALT+MAYÚS+F2 Activa o desactiva el marcador para la línea actual
    ALT+F2 Agrega o quita el acceso directo a la Lista de tareas
    CTRL+MAYÚS+U Convierte la selección a mayúsculas
    CTRL+U Convierte la selección a minúsculas
    CTRL+RETROCESO Elimina la palabra anterior

    Diseñador de informes

    En las ventanas de edición de Visual FoxPro, puede utilizar teclas modificadoras para seleccionar cortar y pegar o copiar y pegar al arrastrar:

    Método abreviado Acción
    CTRL+arrastrar Copia y pega.
    ALT+arrastrar Corta y pega.
    CTRL+TAB Activa el modo de tabulación en el diseñador, de forma que se puede utilizar la tecla Tabulador para desplazarse de un objeto a otro en el informe.
    TAB Utiliza el tabulador para desplazarse al objeto siguiente del Diseñador de informes en modo de tabulación.
    MAYÚSCULAS+TAB Utiliza el tabulador para desplazarse al objeto anterior del Diseñador de informes en modo de tabulación.
    CTRL+E Cambia el control al modo Modificar cuando se selecciona un control Label en el Diseñador de informes. Utilice la tecla ESC para volver al modo Seleccionar.

    En esta versión de Visual FoxPro, puede modificar el comportamiento predeterminado de arrastrar y colocar si hace clic en Arrastrar y colocar entre palabras en la ficha Editor del cuadro de diálogo Opciones del menú Herramientas. Utilice ALT+arrastrar para cambiar al otro valor de configuración (arrastrar en palabras o entre palabras solamente).

    Ventana Vista preliminar

    Método abreviado Acción
    Z Acerca y aleja el zoom.
    L Alterna entre varios niveles de zoom.
    G Abre el cuadro de diálogo Ir a la página.
    ESC Cierra la ventana Vista preliminar.
    FLECHA IZQUIERDA Desplaza la ventana Vista preliminar hacia la izquierda.
    FLECHA DERECHA Desplaza la ventana Vista preliminar hacia la derecha.
    FLECHA ARRIBA Desplaza la ventana Vista preliminar hacia arriba.
    FLECHA ABAJO Desplaza la ventana Vista preliminar hacia abajo.
    AV PÁG Muestra la ventana Vista preliminar en la página siguiente.
    RE PÁG Muestra la ventana Vista preliminar en la página anterior.
    INICIO Muestra la ventana Vista preliminar en la primera página.
    FIN Muestra la ventana Vista preliminar en la última página.

    18 de mayo de 2015

    Herramientas útiles (al menos, yo creo que lo son)

    Artículo original: Useful Utilities (at least, I think they are)
    http://weblogs.foxite.com/andykramek/archive/2006/06/18/1883.aspx
    Autor: Andy Kramek
    Traducido por: Ana María Bisbé York


    Como todos los desarrolladores, cualquiera que sea el lenguaje o entorno preferidos, tengo mi conjunto propio de herramientas y utilidades que utilizo y hacen mi vida más sencilla. Aunque no sean especialmente genéricas, o incluso inteligentes, considero que estas pequeñas cosas ayudan realmente y por eso las ofrezco aquí, tal cual, para su disfrute, adopción y modificación.

    Lo primero es un pequeño fragmento de código que escribí, porque estaba cansado de los errores de escritura en los nombres de las columnas al escribir sentencias SQL - especialmente cuando trabajo con cursores que incluyen columnas calculadas o alias. Esta pequeña rutina llamada GetFList() toma los nombres de los campos de un alias especificado (o del alias actualmente seleccionado si no se especifica nada) y lo coloca en el Portapapeles de Windows. Una vez ahí, la lista puede ser pegada en cualquier ventana con la que tenga que trabajar en ese momento. Sencillo; pero me ha ahorrado muchas horas a lo largo de los años.

    ********************************************************************
    *** Nombre.: GetFList.prg
    *** Autor.....: Andy Kramek
    *** Fecha.....: 7/7/2004
    *** Nota.......: Copyright (c) 2004 Tightline Computers, Inc
    *** Función...: Copia la lista de los campos de la tabla actual,
    *** o una especificada, en el portapapeles
    ********************************************************************
    LPARAMETERS tcTable
    LOCAL lcTable, lcAlias, lcList, lnCnt, lcField, lnSelect
    *** ¿Tenemos el nombre de tabla?
    lnSelect = SELECT()
    IF VARTYPE(tcTable) = "C" AND NOT EMPTY( tcTable )
      lcAlias = JUSTSTEM( tcTable )
      *** Si no está en uso, la abre
      IF NOT USED( lcAlias )
        IF FILE( FORCEEXT( tcTable, 'dbf' ))
          USE (tcTable) AGAIN IN 0 ALIAS (lcALias)
        ELSE
          _CLIPTEXT = ''
          RETURN
        ENDIF
      ENDIF
      *** Y selecciona el Alias
      SELECT (lcAlias)
    ELSE
      *** Utiliza cualquiera que esté abierta
      lcAlias = ALIAS()
    ENDIF
    *** Obtiene la lista de nombres de campos
    IF NOT EMPTY( lcAlias )
      lcList = ''
      FOR lnCnt = 1 TO FCOUNT()
        lcField = LOWER( ALLTRIM( FIELD( lnCnt )))
        lcList = lcList + IIF( EMPTY( lcList ), "", ", " ) + lcField
      NEXT
      *** Agrega el nombre de alias
      _CLIPTEXT = lcList + CHR(13) + CHR(10) + "*** " + lcAlias
    ENDIF
    *** Restablece el área de trabajo
    SELECT (lnSelect)
    RETURN

    La segunda pequeña utilidad es una que llamo, desde las teclas clave (hot-key) en mi entorno de desarrollo, para abrir una instancia del Explorador de Windows en el disco y la carpeta actualmente seleccionada. Confieso que encuentro que es irritante el comportamiento inconsistente de Windows al acceder a ficheros del sistema. Algunas aplicaciones abren una ventana a la última carpeta a la que se ha accedido, otras sencillamente utilizan la estándar ("Mis documentos") o la carpeta estática (C:\ o "Mi PC") y otras hacen algo que tal parece aleatorio. Generalmente, cuando trabajo en VFP, necesito acceder al Explorador de Windows, necesito encontrar un archivo que está en la carpeta actual (por lo general en el directorio raíz o en la jerarquía del proyecto) o en alguna carpeta relacionada de la que conozco, en cualquier caso el nombre (por ejemplo "D:\VFP90\COMMON").

    El procedimiento RunExplorer utiliza la función API ShellExecute() para abrir el Explorador de Windows en la ubicación requerida y yo la llamo empleando un comando ON KEY LABEL que está disponible desde mi tecla de función "F5". Acepta un disco/directorio como parámetro; pero el comportamiento predeterminado es utilizar el directorio de trabajo actual de VFP. He aquí el código para esto:

    ********************************************************************
    *** Nombre.....: RUNEXPLORER.PRG
    *** Autor.........: Andy Kramek
    *** Fecha.........: 25/09/2004
    *** Nota...........: Copyright (c) 2004 Tightline Computers, Inc
    *** Función.......: Ejecuta el Explorador de Windows con el directorio
    ***                 especificado. Si no se pasa un valor, el valor
    ***                 predeterminado es el directorio actual de VFP
    *****************************************************************
    LPARAMETERS tcDir
    LOCAL ARRAY laDex[1]
    LOCAL lcDir, lnDex, llIsLoaded, lcParms, lnRes
    *** Directorio predeterminado, si no es le pasa otra cosa
    IF VARTYPE( tcDir ) # "C" OR EMPTY( tcDir )
      lcDir = FULLPATH( CURDIR())
    ELSE
      *** Directorio predeterminado si el especificado no existe
      IF NOT DIRECTORY( tcDir )
        lcDir = FULLPATH(CURDIR())
      ELSE
        lcDir = tcDir
      ENDIF
    ENDIF
    *** Se asegura de que esté disponible Shellexecute
    lnDex = ADLLS( laDex )
    IF lnDex > 0
      llIsLoaded = (ASCAN( laDex, 'shellexecute', 2, -1, 2, 15 ) > 0)
    ELSE
      llIsLoaded = .F.
    ENDIF
    IF NOT llIsLoaded
      *** Llama a la función
      DECLARE INTEGER ShellExecute IN shell32;
        INTEGER HWND,;
        STRING lpOperation,;
        STRING lpFile,;
        STRING lpParameters,;
        STRING lpDirectory,;
        INTEGER nShowCmd
    ENDIF
    *** Abre el Explorador en la localización correcta
    lcParms = "/N,,/e," + lcDir
    lnRes = ShellExecute( 0, "OPEN", 'explorer.exe', lcParms, "", 1 )
    RETURN

    Incidentalmente, pueden ser utilizados los mismos parámetros ("/n,,/e," + <ruta>) en accesos directos del escritorio para abrir el Explorador de Windows en ubicaciones más útiles que "Mi PC". Generalmente establezco mis accesos directos para utilizar "D:\" una vez que esta es la raíz para mi disco de aplicación y por tanto el mejor lugar por el que quiero comenzar al utilizar el Explorador de Windows  - pero usted puede seleccionar cualquiera.

    La última pequeña utilidad que deseo compartir es una que yo utilizo menos; pero que es igualmente útil. Una de las cosas que yo hago es establecer una ruta específica en VFP (para los detalles, vea mi artículo sobre rutas. Nota de la traductora: El autor se refiere al artículo "The importance of Paths in VFP" - http://weblogs.foxite.com/andykramek/archive/2005/03/21/197.aspx, que se encuentra traducido al español bajo el título "La importancia de las rutas en VFP" y publicado en: http://comunidadvfp.blogspot.com/2003/12/la-importancia-de-las-rutas-en-vfp.html)

    Por supuesto, para especificar una ruta, necesita enumerar todas las carpetas. Me fastidia mucho que Windows no tenga un mecanismo que nos permita copiar una lista de nombres - así que escribí GetSubDirs() para crear una lista, separada por punto y coma, de primer nivel de subdirectorios que existen bajo una raíz especificada y lo coloque en el portapapeles. ¿Por qué solamente el primer nivel? Solamente, debido a que mi estructura estándar de directorios no es más profunda y no necesito controlar nada de complejidad adicional. El código puede ser recursivo para controlar niveles adicionales de subdirectorios; pero esto lo dejo como ejercicio al lector ...

    ********************************************************************
    *** Nombre........: GETSUBDIRS.PRG
    *** Autor.........: Andy Kramek
    *** Fecha.........: 23/09/2004
    *** Nota..........: Copyright (c) 2004 Tightline Computers, Inc
    *** Función.......: Crea una lista separada por ";" de subdirectorios
    ***                 y la copia en el Portapapeles
    ********************************************************************
    LPARAMETERS tcRoot
    LOCAL ARRAY laDirs[1]
    LOCAL lcRoot, lcOrigDir, lnDirs, lnCnt, lcDir, lcList
    *** Necesitamos definitivamente una carpeta raíz
    IF EMPTY( tcRoot ) OR NOT DIRECTORY( tcRoot )
      lcRoot = GETDIR( CURDIR(), "Must specify a Root DIRECTORY", "GET SubDirs" )
      IF EMPTY(lcRoot)
        lcRoot = FULLPATH( CURDIR())
      ENDIF
    ELSE
      lcRoot = FULLPATH( tcRoot )
    ENDIF
    ***Guarda la ubicación actual
    lcOrigDir = FULLPATH( CURDIR() )
    *** Activa el directorio especificado
    SET DEFAULT TO (lcRoot)
    *** Obtiene l lista de subdirectorios de primer nivel
    lnDirs = ADIR( laDirs, '*.', 'D' )
    IF lnDirs = 0
      _CLIPTEXT = ""
      SET DEFAULT TO (lcOrigDir)
      RETURN ""
    ENDIF
    *** Tenemos al menos un subdirectorio
    lcList = ''
    FOR lnCnt = 1 TO lnDirs
      *** Ignora las entradas "." y ".."
      lcDir = LOWER( ALLTRIM( CHRTRAN( laDirs[lnCnt, 1], '.', '')))
      IF EMPTY( lcDir )
        LOOP
      ENDIF
      *** Agrega los directorios a la lita
      lcList = lcList + IIF( EMPTY( lcList ), '', ';' ) + lcDir
    NEXT
    *** Copia los resultados en el portapapeles y devuelve la lista
    SET DEFAULT TO (lcOrigDir)
    _CLIPTEXT = lcList
    RETURN lcList

    24 de abril de 2015

    Secretos ocultos del IDE de VFP (Parte 2)

    Texto original: Hidden Secrets of the VFP IDE, Part 2
    https://msdn.microsoft.com/en-us/library/ms947597.aspx
    Autor: Cathy Pountney
    Traducido por: Ana María Bisbé York


    ... Continuación de Secretos ocultos del IDE de VFP (Parte 1)

    FoxPro ha tenido siempre diferentes vías para hacer lo mismo. Cuántas veces ha mirado sobre el hombro de otro desarrollador y ha dicho, "¡Hey!, ¿Cómo has hecho eso?" En esta serie de artículos, Cathy Pountney va a descubrir muchas formas de trabajar dentro del IDE, especialmente aquellas que no son tan evidentes o no están documentados. Aprenderá varias vías diferentes de mejorar su productividad. Incluso experimentados desarrolladores aprenderán algo nuevo.

    Este es el segundo de dos artículos donde estoy exponiendo varios secretos desconocidos del IDE de VFP. En la primera parte, debatí sobre varios diseñadores, algunos controles, la ventana Propiedades, la herramienta Vista del documento y el cuadro de diálogo Buscar. Además descubrí algunos secretos de IntelliSense y varias herramientas y utilidades incluidas con Visual FoxPro. En este artículo, voy a revelar secretos de la ventana Comandos, varios comandos y para finalizar, resumiré un popurrí de secretos ocultos.

    Ventana Comandos y comandos

    La ventana Comandos es otro lugar en el que pasamos gran parte de nuestro día. Hay varios trucos que se pueden utilizar en la ventana Comandos, y otros secretos menos conocidos sobre algunos comandos de VFP.

    Ventana Comandos

    Mucha gente ya sabe que puede resaltar una línea de código en la ventana Comandos, hacer clic derecho y seleccionar Ejecutar selección para ejecutar el código resaltado. Pero ¿sabía que puede resaltar varias líneas de código y ejecutarlas de una vez? Sin embargo, debe tener en cuenta que este trabajo puede no tener los resultados esperados. Cuando se ejecutan múltiples líneas de código, se crea un programa temporal y luego se ejecuta. Esto significa que las variables pueden irse de alcance después de que un fragmento del código sea ejecutado. ¡Esto es más un "atrape oculto" que un "secreto oculto"!

    Otra cosa que puede hacer con la ventana de comandos es utilizar punto y coma (;), como un carácter de continuación justo como hace en su código. Esto es muy bueno, cuando copia código desde un programa o cuando crea una instrucción SELECT gigante que desea poder ver íntegramente.

    _CLIPTEXT

    El primer extra es una variable de sistema llamada _CLIPTEXT. Contiene el contenido del portapapeles de VFP. Puede utilizarlo para establecer otra información basada en qué hay en el portapapeles, y puede utilizarla precisamente, para definir qué hay en el portapapeles. Es una variable de dos sentidos que debe aprovechar en tiempo de diseño e incluso en tiempo de ejecución dentro de su aplicación.

    Para demostrarlo, resalte una línea de código en la ventana de comandos y presione Ctrl+C para guardarlo en el Portapapeles. Ahora, introduzca ? _CLIPTEXT en la ventana Comandos y verá que la línea de código que ha resaltado está impresa en la pantalla. Otro ejemplo es ejecutar el siguiente código para crear un programa:

    _cliptext = '? "FOX ROCKS"' + CHR(13) + CHR(10) + ;
    '? "VFP 8 ES FANTÁSTICO"' + CHR(13) + CHR(10)
    ERASE JUNK.PRG
    MODIFY COMMAND Junk NOWAIT
    KEYBOARD '{CTRL+V}'

    El código anterior llena el portapapeles con dos líneas de código, crea un archivo de programa, y luego pega el contenido del portapapeles al programa creado recientemente.

    _VFP.DataToClip()

    El segundo extra que tiene VFP para ayudarnos con funciones de cortar y pegar es la función _VFP.DataToClip(). Esta función toma los datos desde la tabla o cursor y los coloca en el portapapeles. Desde ahí, puede pegarlos en cualquier otro lugar, incluyendo Microsoft Excel. El tercer parámetro define el formato de los datos. Si utiliza un 1 (uno) en el tercer parámetro, el dato utiliza un espacio para separar cada campo. Sin embargo, si utiliza un 3 en la tercera columna, se utilizan tabs para separar cada campo, lo cual es perfecto para insertar en Excel u otra aplicación.

    Imprimir el portapapeles

    Otra característica poco conocida en VFP es el hecho de que pueda imprimir lo que sea que esté en el portapapeles. Esto es muy bueno cuando quiere imprimir un fragmento de código de su programa; pero no un programa entero. Resalte el texto que desee imprimir y seleccione Archivo – Imprimir en el menú principal de VFP para llamar al cuadro de diálogo Imprimir (puede utilizar Ctrl.+P para invocar este mismo diálogo). Desde el diálogo Imprimir, seleccione el botón Opciones para mostrar el cuadro de diálogo Opciones de impresión. De forma predeterminada el combobox Tipo aparece relleno con el nombre del programa actual. Sin embargo puede desplegarlo y seleccionar Porta papeles, seleccionar Aceptar y luego regresar al cuadro de diálogo Imprimir para finalizar la selección del resto de los parámetros de impresión.

    Teclas de la ventana Examinar (BROWSE)

    Al utilizar el comando BROWSE, existe un grupo de teclas que pueden ayudarlo a realizar operaciones especiales, como se muestra en la Tabla1.

    Combinación de teclas¿Qué hace?
    Ctrl+FBusca el siguiente (Find)
    Ctrl+GBusca el anterior
    Ctrl+YAñade un regitro
    Ctrl+TAlterna la bandera de eliminar
    Ctrl+HomeEdita un campo memo
    Ctrl+WGuarda y cierra
    Ctrl+F10Alterna entre maximizar y restaurar

    Tabla1. Teclas con el comando BROWSE.

    ¿Qué hay en un NAME?

    La cláusula NAME puede ser muy útil para pasar datos. Los comandos SCATHER, GATHER e INSERT INTO tienen la cláusula NAME. Esto los hace mucho más poderosos que días anteriores cuando hubiera utilizado SCATTER con MEMVAR. Ahora puede utilizar SCATTER con un nombre en NAME, puede pasar el dato a otro objeto como un parámetro. El siguiente código muestra un ejemplo de cómo hacerlo:

    *-- Abrir tablas
    CLOSE TABLES ALL
    USE MyTable1 IN 0
    USE MyTable2 IN 0 EXCLUSIVE
    ZAP IN MyTable2
    *-- Copiar registros desde MyTable1 hasta MyTable2
    SELECT MyTable1
    GOTO TOP
    SCAN
    SCATTER NAME oMyTable
    AddToTableGather('MyTable2', oMyTable)
    AddToTableInsert('MyTable2', oMyTable)
    ENDSCAN
    SELECT MyTable2
    BROWSE
    *-- Cerrar tablas
    CLOSE TABLES ALL
    RETURN
    *************************
    FUNCTION AddToTableGather
    *************************
    LPARAMETERS pcTable, poFields
    LOCAL lcAlias
    lcAlias = ALIAS()
    SELECT (pcTable)
    poFields.Descr = ALLTRIM(poFields.Descr) + 'G'
    APPEND BLANK
    GATHER NAME poFields
    SELECT (lcAlias)
    RETURN
    *************************
    FUNCTION AddToTableInsert
    *************************
    LPARAMETERS pcTable, poFields
    poFields.Descr = ALLTRIM(poFields.Descr) + 'I'
    INSERT INTO (pcTable) FROM NAME poFields
    RETURN

    Otro buen ejemplo de la utilización de la cláusula NAME es con el comando BROWSE. En la ventana comandos, escriba lo siguiente:

    USE MyTable1
    BROWSE NAME oBrowse

    Ahora, en la ventana Comandos, entre la cadena "oBrowse." (no olvide el punto final) y verá el impacto de IntelliSense en cuanto escriba el punto. Esto es muy bueno, la ventana Examinar es ahora un objeto que puede manipular. Empiece a escoger algunas propiedades como FontBold o RowHeight, desde IntelliSense y puede manipular la ventana examinar precisamente desde la ventana Comandos.

    TRANFORM() implícito

    En VFP 8, algunos comandos tienen implementado una característica de TRANSFORM() implícito. Esto significa que puede utilizar los tipos de datos que no son de carácter, y el comando los transformará automáticamente por usted. Si el elemento ha sido transformado es un objeto, es utilizado el texto "(Object)".

    Intente el siguiente comando y se sorprenderá de que no lanzará un error.

    WAIT WINDOW DATE()
    MESSAGEBOX(500)
    DEBUGOUT DATE()
    ? _VFP

    Popurrí

    Existen más secretos ocultos que se desparraman por todo Visual FoxPro.

    Truco tramposo

    Utilizar la tecla Mayúsculas antes de seleccionar una opción de menú, puede cambiar las opciones de menú. Por ejemplo, presionar Mayúscula y seleccionar el menú Archivos cambia la opción Cerrar por Cerrar todo. Utilizar Mayúsculas desde la ventana de menú cambia, Ocultar por Ocultar todo. Normalmente, la opción Formato – Fuente cambia la fuente en la ventana de Comandos. Sin embargo, utilizar la tecla Mayúsculas con el menú Formato cambia la fuente de la pantalla, por tanto, cambia la fuente de la pantalla de VFP.

    Otra característica, que tiene ya cerca de años y años en FoxPro y VFP, es la característica de Fuera de vista (outshow) Presionar Ctrl+Alt+Shift oculta todas las ventanas excepto la de salida. Están ocultas mientras continúe presionando la combinación de teclas. En cuanto las libere, las ventanas ocultas aparecen nuevamente. Esto es extremadamente útil cuando muestra algo desde la ventana de comandos con el carácter signo de interrogación (?) y el resultado final se mostrará detrás del resto de las ventanas.

    Copiar una clase

    De inicio, parece como si no hubiera una forma de copiar una clase existente en VFP. Puede crear una subclase; pero al parecer no hay forma de copiar una clase. Entonces, utilizará el Administrador de proyectos que puede lograrse bastante fácil con los siguientes pasos:

    1. Arrastre la clase origen desde una biblioteca a otra.
    2. Renombre la clase en la nueva biblioteca.
    3. Arrastre nuevamente la clase renombrada a la biblioteca original.
    4. Elimine la clase de la biblioteca temporal.

    Por supuesto, sería agradable si existiera un botón copiar en el menú contextual que se activa con el clic derecho o en algún otro lugar. Pero ¡al diablo!,… no podemos tenerlo todo.

    Arrastrar y soltar

    En VFP 8, el Administrador de proyectos fue mejorado al permitir adicionar múltiples archivos a la vez. Antes de esta versión, podía añadir solo un archivo cada vez. Sin embargo, puede arrastrar y soltar múltiples archivos, y esta característica ya está hace algún tiempo. Abra el Administrador de proyecto y el Explorador, seleccione algunos archivos en el Explorador y luego arrástrelos al Administrador de proyectos. Una ventaja adicional es que el Administrador de proyectos es suficientemente inteligente como para colocar cada archivo en su ficha correspondiente, en dependencia de la extensión del archivo.

    _VFP.SetVar()

    Esta función, tan poco conocida, puede ser utilizada para establecer variables en situaciones donde no puede ejecutar un comando; pero puede llamar a una función. Un ejemplo perfecto de cuando utilizarla es el Diseñador de informes. Yo la utilizo todo el tiempo en expresiones Al Entrar (OnEntry) y Al Salir (OnExit) de varias bandas del informe. Por ejemplo, en la expresión Al Salir en el Pie de grupo, puede utilizar _VFP.SetVar('rnRecordCount', 0) para limpiar el valor de la variable rnRecordCount. O, cuando utiliza _VFP.SetVar('rnCountDataGroups', rnCountDataGroups+1) para incrementar una variable que almacena la cantidad de grupos de datos procesados.

    Caracteres comodín

    Algunos comandos aceptan caracteres comodín, y, a pesar de que es grandioso poder trabajar con ellos, puede ser peligroso. No hay mucho daño en escribir MODI COMM MyProg*. Todo lo que va a hacer es abrir todos los programas que comiencen con MyProg. Sin embargo, el tema de escribir DELETE FILE MyProg*.prg … ¡Peligro!¡Peligro!¡Peligro!... cruzan destellos por mi mente. ¡Sea muy cuidadoso a la hora de utilizar caracteres comodín!

    Sólo por diversión

    ¡Vaya! Tenemos aquí un artículo lleno de información. Hasta ahora, su cerebro está probablemente confundido, por eso, voy a finalizar con algunas cosas divertidas.

    Filer

    Años atrás, Filer fue lo más utilizado por desarrolladores de Visual FoxPro para Buscar y encontrar archivos. Después de VFP 3.0, desapareció y muchos desarrolladores se quejaron. Bueno, el Equipo de Fox ha escuchado y decidido traerlo de regreso. Escriba lo siguiente en la ventana de Comandos, para ver un ejemplo de cómo ejecutarlo.

    DO FORM (HOME(1) + 'Tools\Filer\Filer.scx')

    Busque en el archivo de Ayuda de VFP y lea sobre el Nuevo Filer, porque este es orientado a objetos y puede interactuar con el e implementarlo en sus propias aplicaciones. ¡Supongo que podrá llamarlo FilerX!

    Puzzle

    Esta es otra característica de VFP que nos ha sido devuelta con VFP 8.0. Escriba lo siguiente en la ventana de Comandos. Sin embargo, está advertido… ¡puede disminuir drásticamente su productividad en el trabajo!

    ACTIVATE WINDOW PUZZLE

    Programas libres de errores

    ¿Sabe que escribir programas libres de errores, es muy fácil con VFP? Sólo necesita escribir la siguiente línea de código en su programa de inicio, y ya está cubierto.

    ON ERROR *

    Por supuesto, esto no significa que sus programas están libres de fallas. Significa solamente que no se emitirán mensajes de error por el sistema.

    ¡Ame su trabajo!

    Estoy segura que ama VFP tanto que nunca quisiera dejarlo ir. Muy bien, no hay problemas. Al iniciar VFP, escriba la siguiente línea de código:

    ON SHUTDOWN *

    No importa, cuánto se esfuerce, no podrá salir de VFP. Esto es genial – ahora puede estar con VFP 24 horas, 7 días de la semana y ¡nunca tendrá que dejarlo! Bien, bien, no es una muy buena idea. Para reparar los daños hay que escribir el siguiente código:

    ON SHUTDOWN

    ¡Trabaje Mejor, no Más!

    Este par de artículos están abarrotados de información. Mi objetivo es exponerle tantas características como son posibles y dejarle sus momentos "ah ha". Algunas de ellas pueden que no sean novedosas; pero aquellas que sí le han sido descubiertas, le permitirán ahorrar tiempo en el futuro. Como siempre digo, ¡Trabaje mejor, no más!

    Para encontrar más sobre FoxTalk y Publicaciones Pinnacle (Pinnacle Publishing) visite su sitio Web en http://www.pinpub.com

    Nota: Este no es un sitio Web de la corporación Microsoft. Microsoft no es responsable por su contenido. Este artículo está reproducido de la edición de este mes de enero de 2004 de FoxTalk, Copyright 2004, por Pinnacle Publishing, Inc., sin alguna otra nota. Todos los derechos reservados. FoxTalk es una publicación independiente de Pinnacle Publishing, Inc. Ninguna parte de este artículo puede ser reproducido (excepto en breves acotaciones utilizadas en revistas y artículos especializados) sin previo consentimiento de Pinnacle Publishing, Inc. Para contactar con Pinnacle Publishing, Inc, favor de llamar al 1-800-788-1900.

    23 de abril de 2015

    Secretos ocultos del IDE de VFP (Parte 1)

    Texto original: Hidden Secrets of the VFP IDE, Part 1
    https://msdn.microsoft.com/en-us/library/ms947595.aspx
    Autor: Cathy Pountney
    Traducido por: Ana María Bisbé York


    FoxPro ha tenido siempre diferentes vías para hacer lo mismo. Cuántas veces ha mirado sobre el hombro de otro desarrollador y ha dicho, "¡Hey!, ¿Cómo has hecho eso?" En esta serie de artículos, Cathy Pountney va a descubrir muchas formas de trabajar dentro del IDE, especialmente aquellas que no son tan evidentes o no están documentados. Aprenderá varias vías diferentes de mejorar su productividad. Incluso experimentados desarrolladores aprenderán algo nuevo.

    En la parte 1 de esta serie de dos partes, voy a descubrir algunos secretos ocultos en varias áreas de Visual FoxPro. Se comentarán varios diseñadores, unos pocos controles, la ventana Propiedades, la ventana Vista de documento (Document View), el cuadro de diálogo Buscar, Intellisense y un grupo de herramientas y utilidades incluidas con el Visual FoxPro. En la parte 2 se revelarán los secretos de la ventana de comandos y varios comandos, y se resumirán un popurrí de secretos ocultos.

    Diseñador de Informes

    Por supuesto ya sabe que comenzaré con mi diseñador favorito, ¡El diseñador de informes!

    Navegar entre objetos

    En VFP 8, puede navegar entre los controles de un informe simplemente utilizando Tab para el control siguiente y Shift+Tab para el control anterior. En versiones previas a VFP8, necesitaba utilizar Ctrl+Tab para obtener primero el modo Tab, y luego poder hacer Tab entre los objetos con las teclas Tab y Ctrl+Tab.

    Modificar una etiqueta existente

    Para modificar un objeto etiqueta existente en un informe, simplemente seleccione el objeto y luego presione Ctrl+E. Esto activa el modo edición de tal forma que puede cambiar el texto de la etiqueta.

    Diseñador de formularios

    VFP tiene algunos trucos para trabajar con contenedores.

    Llegar a los objetos dentro de los contenedores

    Trabajar con los contenedores, tales como el pageframe (marco de página), puede ser difícil a veces. Sin embargo, puede modificar rápidamente el objeto dentro del contenedor utilizando Ctrl+Clic sobre el objeto. Esto "pasa por encima" del contenedor y le permite tomar el control del objeto que está dentro.

    Si existen contenedores dentro de otros contenedores, puede utilizar Ctrl+Shift+Clic para profundizar aun más en el nivel. Por ejemplo, si tiene un control optiongroup en una página de un pageframe, puede posicionar su cursor en una la las opciones (optionbuttons), presionar Ctrl+Shift+Clic, y VFP pasa por encima de los controles pageframe, page y optiongroups y va directo al control optionbutton.

    Controles ListBox y ComboBox

    El carácter "\" tiene especial significado al utilizar listBox y combobox – vea Tabla 1 para más detalles.

    CarácterDescripción
    \Si se utiliza "\" como primer carácter, el elemento es inhabilitado entero.
    \\Debido a que una barra inversa tiene especial significado, si verdaderamente necesita una barra "\" en el elemento, debe colocar dos barras juntas.
    \]Debido a que la barra simple al inicio del elemento significa que debe ser inhabilitado, si verdaderamente desea que el elemento comience con barra invertida debe utilizar "\]" para indicar que no debe estar inhabilitado.
    \-Una barra inversa seguida por un guión significa que desea dibujar una línea horizontal para este elemento.

    Tabla 1. Utilizar el carácter "\" en ListBox y ComboBox

    Controles Grid

    Los controles Grid han presentado siempre dificultad para trabajar, especialmente para nuevos desarrolladores, debido a que algunas cosas no son muy intuitivas.

    Agregar controles

    Cuando las columnas son agregadas a las cuadrículas (grid), tienen automáticamente dos controles – un control header (encabezado), llamado header1 y un control textbox llamado Text1. Sin embargo, en muchos casos necesita otro control en lugar del textbox. Desafortunadamente, no es fácil intuir como añadir y eliminar controles de las columnas.

    Lo primero que hay que hacer es entrar al grid. Coloque su ratón sobre uno de las líneas de la columna que desea cambiar y presione Ctrl+Clic. Asegúrese de estar en una de las filas de datos y no en la fila del encabezado. Ahora tiene activa la columna y puede utilizar la barra de herramientas de controles del formulario para arrastrar y soltar el objeto que desee en la columna.

    Al arrastrar el objeto a la columna, no se aprecia que haya ocurrido nada. Sin embargo, si mira la ventana propiedades y se posiciona en la columna, verá que el objeto original text1 se encuentra junto al que acaba de agregar. La propiedad CurrentControl está establecida aun en el control textbox Text1, por eso es que todavía no ve el control agregado.

    Si hubiera cambiado la propiedad CurrentControl de la columna al nombre del objeto que ha agregado, el grid le mostrará el objeto. Sin embargo, si realmente no necesita el textbox text1 original, puede liberarlo y no preocuparse por la propiedad CurrentControl.

    Eliminar controles

    Si piensa que agregar controles no es intuitivo, estoy segura que se asombrará mucho cuando aprenda cómo eliminar un control indeseado. Es lo más poco intuitivo que hay. Primero, seleccione el control que desee eliminar en la ventana propiedades. Luego, haga clic con el ratón en una fila de datos de su grid y luego presione la tecla Suprimir para eliminar el control. Es posible que no ocurra nada en el grid, si mira en la ventana Propiedades no estará el control.

    Navegación

    Los grids presentan otro problema para los usuarios finales. Los usuarios están acostumbrados que la tecla Tab los lleve al otro control. Sin embargo, cuando está dentro del grid, Tab mueve el cursor entre las columnas del grid. Entonces, ¿cómo debe hacer el usuario para salir del grid? La respuesta es utilizar Ctrl+Tab para navegar hacia el control posterior al grid o utilizar Ctrl+Shift+Tab para navegar hacia el control anterior al grid.

    La ventana propiedades

    Existen diferentes teclas de acceso directo para invocar, navegar y establecer valores en la ventana Propiedades (vea la Tabla 2).

    Método abreviado Descripción
    Alt + Doble ClicDesde el diseñador de formularios, esta combinación active la ventana propiedades aún si no se estaba mostrando.
    Clic derecho (Ventana propiedades)Al presionar clic derecho en un área de la ventana Propiedades que está inutilizada muestra un menú con opciones adicionales. La opción Sólo propiedades no predeterminadas mostrará sólo las propiedades con valores no predeterminados.
    Clic derecho (propiedades)Al presionar clic derecho en una propiedad cuyo valor es de caracteres muestra un menú con la opción Zoom. Seleccione Zoom para mostrar una ventana de edición grande para ver el valor de la propiedad.
    Shift+ Flecha arriba / Flecha abajoPresionar esta combinación cuando se está en una propiedad con múltiples valores permite navegar por todos los posibles valores de la propiedad.
    .Cuando está en una propiedad con valor lógico, el punto alterna entre .t. y .f.
    Ctrl+ Página arriba/ Página AbajoEsta combinación hace que el cursor vaya al objeto siguiente o previo en la ventana Propiedades.
    Ctrl+ Inicio/FinEsta combinación hace que el cursor vaya al objeto primero o posterior en la ventana Propiedades.
    Ctrl+Alt+<letra>Presione Ctrl+Alt más alguna letra para saltar a la primera propiedad, método o evento que comienza con esa letra.

    Tabla 2. Teclas de acceso directo para invocar, navegar y establecer valores en la ventana Propiedades.

    Editor

    Muchos de nosotros pasamos mucho tiempo dentro del editor de código de VFP. Después de todo, es lo que hacemos – ¡escribir código! Las siguientes pistas develan algunos de los secretos ocultos del editor.

    Vista de documento

    La herramienta Vista de documento es una gran herramienta que le permite navegar por el código a través de varios procedimientos y funciones. Pero ¿sabe que no necesita activar la ventana Vista de documento para tomar ventaja de esta característica? En cuanto se abre la ventana de Vista de documento, puede presionar Ctrl+PageUp y Ctrl+PageDown para navegar a través del elemento en la lista. No necesita saltar a la Vista de documentos, navegar por el, y luego saltar al programa.

    Mayúsculas y minúsculas

    Si es un porfiado sobre las mayúsculas y minúsculas, puede utilizar Ctrl.+U para convertir el texto seleccionado a minúsculas y Ctrl+Shift+U para convertirlo a mayúsculas

    Marcadores

    Los marcadores son muy buenos cuando trabaja con mucho código. Puede leer a través de algún código y ver referencias de otro método o función. Por supuesto, necesita echar un vistazo a ese código y luego saltar atrás a donde estaba antes, al finalizar. Puede hacerlo más rápido empleando marcadores (bookmarks). Hay que marcar la ubicación existente presionando Alt+Shift+F2. Ahora vaya al otro código que necesita mirar y al finalizar, presione F2 o Shift+F2 para regresar al código anterior. El saltar entre diferentes secciones de código, puede permitirle ahorrar mucho tiempo si marca cada sección con un marcador.

    Cuadro de diálogo Buscar

    La tabla3 muestra los efectos de utilizar el carácter "\" en el cuadro de diálogo Buscar. Realmente no buscará el carácter de barra inversa, en su lugar, provocará que el diálogo Buscar busque otros caracteres especiales.

    CarácterDescripción
    \tBusca caracteres Tab
    \rBusca el final de cada línea
    \nBusca el inicio de cada línea
    \\Busca el carácter "\"

    Tabla 3. Utilizar el carácter "\" en el diálogo Buscar.

    Las búsquedas "\r" y "\n" tienen algunas trampas. Escriba "\r" en el cuadro de diálogo Buscar y presione el botón Buscar siguiente. Al inicio parece como si nada hubiera ocurrido, sin embargo, mantenga presionado el botón Buscar siguiente y verá un cuadro en su código en la primera línea en blanco.

    Lo que ocurre es que como Buscar "\r" va al final de cada línea de código; el cursor no se ilumina; pero realmente está situado al final de la línea. Cada vez que presiona Buscar siguiente, va al final de la línea siguiente pero no tiene ninguna pista visual hasta que choca con una línea en blanco. Para demostrar que está trabajando realmente, active el editor y escriba una letra. Verá la letra al final de la línea. Lo mismo es válido cuando se hace una búsqueda por "\n" excepto que el cursor va al inicio de cada línea. Sin embargo, al buscar por "\n" no verá nunca el cursor.

    Los caracteres "\\" buscan la primera barra inversa "\" como una salida y luego tratan de buscar la segunda barra como el carácter a ser buscado. Por lo tanto, la búsqueda por "\\" encontrará una sola barra inversa. Sin embargo, esto en realidad no es necesario, porque una barra inversa en el cuadro de diálogo Buscar, encontrará todas las barras inversas.

    Cuadro de diálogo Buscar – caracteres comodín

    Una de las casillas de verificación del cuadro de diálogo Buscar es Usar caracteres comodín, Seleccionar esta opción le permitirá utilizar caracteres especiales para establecer la coincidencia. Tabla 4 muestra que está disponible.

    CarácterCoincidencia con comodín
    ?Único carácter
    *Múltiples caracteres
    #Único dígito
    <Coincidencia con caracteres al inicio
    >Coincidencia con caracteres al final
    [ ]Lista de caracteres
    [!]Lista de excepciones

    Tabla 4. Utilizar caracteres especiales para establecer coincidencia en el cuadro de diálogo Buscar.

    Los símbolos "?", "*", y "#" se explican por si solos; pero algunos de los otros elementos necesitan mayor explicación. Buscando por "<Fox" encontrará sólo aquellas palabras que comiencen con "Fox". Si tiene una variable llamada lcFox, no será encontrada, porque no comienza con Fox. En la otra cara de la moneda, "Fox>" encuentra sólo aquellos elementos que terminen con "Fox". Por consiguiente, encontrará la variable lcFox; pero, no encontrará una variable llamada lcFox1, Los caracteres "[" y "]" pueden ser utilizados juntos para encontrar una lista de elementos. Por ejemplo, "lcFox[1-2]" encontrará variables llamadas lcFox1 y lcFox2. Otro ejemplo es "lcFox[1,2,4]", la que va a encontrar lcFox1, lcFox2, y lcFox4. Sin embargo, no encontrará lcFox3.

    Utilizar el signo "!" con los corchetes cambia el significado a una lista de excepciones en lugar de la lista de lo que se está buscando. Buscar por "lcFox[!2]" encontrará lcFox1, lcFox3, lcFox4, etc; pro no encontrará lcFox2. De esta misma forma, "lcFox[!2-3]" que encontrará lcFox1 y lcFox4, pero no encontrará lcFox2 y lcFox3.

    IntelliSense

    IntelliSense se introdujo con el VFP 7, y puedo decir, que merece la pena la actualización, aunque sea sólo por esta característica. Personalmente, no puedo vivir más sin IntelliSense. Si tengo que trabajar en un proyecto de VFP previo a VFP 7, me volvería loca. De hecho, usualmente hago todas mis modificaciones en VFP 7 o VFP 8, y luego utilizo las versiones antiguas sólo para compilarlas.

    Operador expansión

    Con IntelliSense viene un grupo de características de teclas, así como el operador expansión. ¿Cuántas veces ha escrito lnCount = lnCount + 1? Juro que lo he hecho un millón de veces hasta ahora. Pero, estos días, puedo cortar escribiendo lnCount++, presiono la barra espaciadora, y listo. VFP lo expandirá a lo que yo quiero. La tabla 5 muestra todo del operador expansión disponible.

    Esto...Expande a…
    cVar++cVar = cVar + 1
    cVar--cVar = cVar - 1
    cVar+=cVar = cVar +
    cVar-=cVar = cVar -
    cVar/=cVar = cVar /
    cVar*=cVar = cVar *

    Tabla 5. Opciones de operador expansión.

    Teclas de acceso directo IntelliSense

    He visto gran número de desarrolladores comenzar a escribir, aprovechar las ventajas de IntelliSense, y luego, darse cuenta de que han cometido un error. Lo que hacen es comenzar a borrar con la tecla retroceso hasta llegar al punto "." Sin embargo, esto no es necesario. Ctrl+J va a listar los miembros del objeto sin ir hacia atrás hasta el punto. Puede utilizar además Ctrl+J después del signo igual para listar los valores asociados con una propiedad particular, y Ctrl+I puede ser utilizado para mostrar información rápida.

    Ponga el siguiente código de ejemplo en un programa y luego posicione el cursor como se instruye y presione el apropiado Ctrl+J o Ctrl+I para ver que funciona.

    *-- Intellisense
    LOCAL loForm AS Form 
    *-- CTRL+J para listar los miembros
    *-- (coloque el cursor después del punto)
    loForm.
    *-- CTRL+J para listar los valores 
    *-- (coloca el cursor después del signo igual)
    loform.alwaysontop = 
    loForm.BorderStyle =
    *-- CTRL+I for Quick Info 
    *-- (coloca el cursor en uno de los parámetros)
    SEEK(cMyValue, cMyTable, cIndex)

    Registros predefinidos "U"

    IntelliSense es completamente extensible porque todo es guardado en una tabla DBF. Puede ver estas tablas escribiendo USE (_FOXCODE) SHARED en la ventana de comandos. Si se mueve cerca del inicio de esta tabla, verá varios registros con el tipo de "U". El equipo de VFP ha cargado varios ejemplos de cómo puede cortar sus teclas entrando registros de estos tipos. Puede copiar estos registros a nuevos registros y comenzar a agregar sus propios registros para cosas que hace de forma habitual.

    La tabla 6 muestra los registros predefinidos "U" en VFP 8. Algunos de estos trabajos en la ventana Comandos y otros trabajos dentro del editor de programas y código de método.

    Esto...Expande como …
    MFModify File
    MCModify Command
    DCDefine Class
    ZdefMuestra #DEFINEs
    ZlocMuestra variables locales
    DOCASEDO CASE
    CASE
    OTHERWISE
    ENDCASE
    DOWHILEDO WHILE
    ENDDO
    IFENDIF
    ENDIF
    IFELSEIF
    ELSE
    ENDIF
    TRYENDTRY
    CATCH
    FINALLY
    ENDTRY
    FOREACHFOR EACH
    ENDFOR
    FORENDFOR
    ENDFOR
    SCANENDSCAN
    ENDSCAN
    TEXTENDTEXT TO NOSHOW TEXTMERGE
    ENDTEXT
    WITHENDWITH
    ENDWITH

    Tabla 6. Registros predefinidos "U" en VFP 8.

    Les animo a crear su propio registro "U" para simplificar su escritura diaria. Así, probablemente no le sorprenda que yo haya agregado a mi tabla _FOXCODE, MR para expandir como MODIFY REPORT. Otro cambio que puedo hacer es cambiar el registro MF para expandir como MODIFY FORM en lugar de MODIFY FILE.

    Herramientas de VFP y utilidades

    VFP está lleno de herramientas nativas y utilidades para ayudarlo a ser más productivo cada día. Algunas de estas herramientas tienen ya años y años, y otras, son nuevas en VFP 8.0. No escribiré mucho sobre cómo utilizar estas herramientas, porque eso merece un artículo por si mismo. Sólo quiero que sea consciente de estas herramientas para que pueda utilizarlas.

    Class Browser (Examinador de clases)

    El examinador de clases tiene una pequeña lista MRU - Utilizado más recientemente (Most Recently Used) – a la que puede acceder al hacer clic derecho sobre los botones. Puede ver la lista de Documentos recientes (MRU) desde los botones Abrir, Ver archivo adicional y el botón Galería de componentes.

    Utilizar clic derecho con el botón Ver código de clases cambia ligeramente el comportamiento. La ventana de edición que aparece con el código es pequeña y cabe dentro del marco derecho del examinador de clases. De hecho, puede hacer clic en el botón Ver código de clase (View Class Code) para traer el código para una clase, y luego utilizar clic derecho para traer el código de una segunda clase.

    Una de las características más útiles y menos conocidas del examinador de clases son sus posibilidades de arrastrar y soltar a un formulario. ¡¡La clase seleccionada es soltada en un formulario!!. Puede además arrastrar el icono de la clase a la ventana de comandos y el código NEWOBJECT es generado por usted.

    Depurador

    ¿Sabe que puede arrastrar y soltar desde dentro del depurador? Puede resaltar una variable en la ventana Seguimiento y luego arrastrarla hasta la ventana Inspección. Esto puede ahorrar tiempo ya que no necesita escribir variables con largos nombres, y reduce las posibilidades de errores de escritura incorrecta. Puede además arrastrar una variable desde las ventanas Inspeccionar o Local a la ventana Comandos o el editor.

    Otra fantástica característica del editor es que puede cambiar los valores de variables a voluntad. Una vez que una variable está en la ventana Inspección o Local, puede resaltar su valor (Value) y escribir lo que desee. Esto es muy bueno, si se da cuenta que hay valores mal establecidos y desea continuar la ejecución para ver si el resto va bien. Además de escribir un nuevo valor, puede escribir una expresión para que sea evaluada inmediatamente. Por ejemplo, para una variable de tipo fecha, puede escribir DATE() y en cuanto presione la tecla Return (Intro), el valor de la variable queda establecido en la fecha actual.

    Referencias de código – nuevo en VFP 8.0

    En mi opinión, esta herramienta no tiene el nombre correcto, ya que es en realidad una fabulosa herramienta de búsqueda – que trabaja más allá que con el código. Esta herramienta permite buscar por un proyecto entero determinada cadena. Puede buscar programas, clases, informes, y todo tipo de archivos en un proyecto. Busca además propiedades y en los códigos de los métodos.

    Además de ser una herramienta de búsqueda, es una herramienta que permite sustituir. Puede decirle que sustituya todas las ocurrencias que encuentre o algunas ocurrencias específicas. Esto hace cambios masivos en su aplicación de forma muy simple.

    Administrador de paneles (Task Pane) – nuevo en VFP 8.0

    El Administrador de paneles es un portal que lleva a diferentes aspectos del Visual FoxPro, incluyendo los ejemplos Solutions y las Comunidades de desarrolladores de Visual FoxPro. Como sucede con muchas herramientas en Visual FoxPro, puede personalizar esta herramienta profundizando en su contenido más interno, llegando al corazón mismo. La personalización puede ser distribuida a otros al exportar e importar archivos XML sencillos. Se espera que más de la tercera parte de los desarrolladores de herramientas y utilidades ofrezcan sus propios add-ins en el Panel de tareas.

    ToolBox – Nuevo en Visual FoxPro 8.0

    El ToolBox puede considerarse un reemplazo a la barra de herramientas de controles del formulario – pero es mucho más que eso. Puede agregar todas sus clases más comúnmente utilizadas a esta herramienta y esto le hará diseñar con más facilidad sus formularios. Pero puede aprovechar muchas otras ventajas que no son muy conocidas.

    Una categoría del ToolBox es Text Scraps (fragmentos de texto). Significa que le permite predefinir un conjunto de texto y luego pegarlo en sus programas y sus códigos de métodos. Además, no está limitado a VFP, puede pegar fragmentos de texto de otras aplicaciones, como por ejemplo Microsoft Word.

    Uno de los elementos que puede agregar al ToolBox es un archivo. Sin embargo, puede utilizar esta característica para agregar nuevas cosas que no son realmente archivos. Por ejemplo, agregar un archivo ficticio y luego cambiar las propiedades en una URL. Al seleccionar este elemento desde el ToolBox, el Explorador de Internet (o cualquier otro examinador que tenga establecido) emerge e intenta ir a esa URL. Entonces, si existen algunos sitios Web que visita de forma regular durante el desarrollo de sus aplicaciones, colóquelos en el ToolBox con accesos rápidos.

    Otra cosa que puede hacer con la opción File (Archivos), es apuntar hacia un directorio. Primero, tiene que definir un archivo ficticio y luego cambiar sus propiedades para ir al directorio, en lugar de ir a unos archivos. Al seleccionar esta opción desde el ToolBox, el Explorador emergerá con este directorio como predeterminado. Si ve que siempre navega por el mismo directorio, agréguelo al ToolBox y ahorre tiempo.

    Foundation Clases

    Déle un vistazo al directorio FFC en el directorio raíz de VFP (DIR HOME(1) + 'ffc\*.*') y verá toneladas de clases que han sido definidas. Estas clases fueron creadas por el Grupo de desarrollo de VFP para ayudarlo con sus aplicaciones. Algunas de ellas son justamente subclases de clases base de VFP. Sin embargo, muchas otras son clases, que puede utilizar con sus aplicaciones, como la clase para mostrar un termómetro de progreso.

    Ejemplos Solutions

    Escriba el siguiente comando en la ventana de comandos y se sorprenderá de lo que ocurre:

    DO (HOME(2) + 'solution\solution.app')

    Al navegar por la estructura de árbol, verá toneladas de ejemplos de cosas que puede querer en sus aplicaciones. La interfaz de usuario le permitirá ejecutar los ejemplos o ver el código para ver cómo se hace. Es una gran herramienta de aprendizaje, para entender cómo se hacen las cosas en VFP.

    HexEdit

    Si ha necesitado alguna vez un editor hex para examinar un archivo (hack), sabrá que este programa puede ser un salva-vidas. O si su curiosidad le está volviendo loco, puede utilizar el HexEditor para ojear en un fichero DBF y ver exactamente cómo almacena los datos. ¡Puede ser una gran experiencia instructiva!

    Puede encontrarlo en C:\Program Files\Microsoft Visual FoxPro 8\Tools\HexEdit\hexedit.prg.

    GenDBC

    Cuando se ejecuta este programa, crea todo el código necesario para re-crear su DBC. Puede ser muy útil para crear e instalar una nueva aplicación. No necesita enviar todos lo archivos de datos. En su lugar, está listo para distribuir su aplicación, con sólo ejecutar este programa en su PC y poner el programa creado en su proyecto. Haga que su programa de instalación ejecute el programa generado por el GenDBC, y la nueva instalación se inicializará y ejecutará sin pérdida de tiempo.

    Es además, una gran vía para obtener uno o dos archivos copiados en otra DBC y guardar todo sobre el mismo. Ejecute GenDBC en la DBC original. Luego, modifique el programa creado y borre todo menos el código que genera los pocos archivos que desea. Cambie el nombre de la DBC en el programa y re-ejecútelo para agregar estos archivos a diferente DBC.

    Puede encontrarlo en C:\Program Files\Microsoft Visual FoxPro 8\Tools\Gendbc\gendbc.prg.

    xSource

    A veces, la mejor vía para aprender acerca de algo es bucear en el código que hay detrás. Muchas de las herramientas y utilidades de VFP estás actualmente escritas ¡con el propio código de VFP! El código fuente para todas estas herramientas están incluidas en un archivo .zip que se guarda en la carpeta C:\Program Files\Microsoft Visual FoxPro 8\Tools\xsource. Cuando tenga algo de tiempo, descomprima este archivo y comience a bucear en él para ver cómo el equipo Fox ha logrado muchas cosas maravillosas en las herramientas y utilidades nativas de FVP.

    "Ah ha"

    Siempre disfruto escribiendo sobre "pistas y trucos", como ya he hecho en ese artículo. Incluso experimentados desarrolladores tienen por obligación su momento "ah ha". Existe mucho en FoxPro así que es difícil para una persona saberlo todo. En el próximo artículo de esta serie, voy a hablar de la ventana de comandos, algunos comandos y un conjunto de ideas varias.

    Para encontrar más sobre FoxTalk y Publicaciones Pinnacle (Pinnacle Publishing) visite su sitio Web en http://www.pinpub.com

    Nota: Este no es un sitio Web de la corporación Microsoft. Microsoft no es responsable por su contenido. Este artículo está reproducido de la edición de este mes de enero de 2004 de FoxTalk, Copyright 2004, por Pinnacle Publishing, Inc., sin alguna otra nota. Todos los derechos reservados. FoxTalk es una publicación independiente de Pinnacle Publishing, Inc. Ninguna parte de este artículo puede ser reproducido (excepto en breves acotaciones utilizadas en revistas y artículos especializados) sin previo consentimiento de Pinnacle Publishing, Inc. Para contactar con Pinnacle Publishing, Inc, favor de llamar al 1-800-788-1900.

    Continua en ... Secretos ocultos del IDE de VFP (Parte 2)

    5 de abril de 2015

    ¿Es una variable o propiedad un array?

    Cuando validamos un parámetro en una función o procedimiento, a veces es necesario determinar si el parámetro pasado es una matriz (array). Hasta VFP 9.0 no había una manera evidente de hacerlo.

    En VFP 9.0 la función TYPE() acepta un segundo parámetro adicional: 1, para determinar si se la expresión pasada es una matriz, una colección o ninguno de los dos. En versiones anteriores de VFP podemos usar la función TYPE() en combinación con la función ALEN().

    Este es el código de ejemplo:

    && VFP 9.0
    IF TYPE("AlgunaVariableOrPropiedad",1) = "A"
      && Es un array
    ENDIF
     
    && VFP 8.0 y anteriores
    IF TYPE("ALEN(AlgunaVariableOrPropiedad)")) = "N"
      && Es un array
    ENDIF

    Comprobar que TYPE("AlgunaVariableOrPropiedad[1]") = "N" no funciona para propiedades intrínsecas de VFP. Retornando "N" para estas.

    loForm = CreateObject ( "Form") 
    ? TYPE("loForm.Top[1]") && Retorna N

    Entrada Original: http://www.berezniker.com/content/pages/visual-foxpro/-varable-or-property-array

    28 de febrero de 2014

    NotePad++ (NotePad plus) y Visual FoxPro

    "VISUAL FOXPRO" EN NOTEPAD++

    NotePad++ permite que el usuario defina las características de coloreado y envoltura para un lenguaje no definido de forma nativa, en este articulo proporciono una configuración "sugerida" para el leguaje de "Visual FoxPro".

    Notepad++ es un editor de texto GPL con soporte para varios lenguajes de programación que incluye opciones avanzadas para desarrolladores.

    Este editor incluye características como coloreado y envoltura de sintaxis, pestañas, resaltado de paréntesis e indentación, grabación y reproducción de macros y soporte de extensiones.

    Entre los lenguajes de programación que soporta están Ada, ASP, ASM Ensamblador (x86), ASM Ensamblador (Z80), AutoIt, Batch, C, C#, C++, Caml, CMake, COBOL, CSS, D, Diff, Flash ActionScript, Fortran, Gui4Cli, Haskell, HTML, INNO, Java, JavaScript, JSP, KiXtart, Lisp, Lua, Makefile, MATLAB, MS INI (archivo), NSIS, Objective-C, Pascal, Perl, PHP, PostScript, PowerShell, Properties, Python, R, RC (fichero de recurso), Ruby, Shell, Scheme, Smalltalk , SQL, Tcl, TeX, VB, VHDL, Verilog, XML, YAML.

    Lamentablemente de forma nativa no incluye "Visual FoxPro", sin embargo se puede personalizar de tal forma que soporte el lenguaje, a continuación se explica como hacerlo.

    INSTALE NOTEPAD++

    Ingrese a la pagina del creador http://notepad-plus-plus.org, descargue e instale la ultima versión.

    "VISUAL FOXPRO" EN NOTEPAD++

    NotePad++ permite que el usuario defina las características de coloreado y envoltura para un lenguaje no definido de forma nativa, en este articulo proporciono una configuración "sugerida" para el leguaje de "Visual FoxPro".

    Descargue los archivos

    Definicion de Visual FoxPro (UDL)
    Opcionales
    Funciones/Procedimientos en programa (functionList.xml)
    NotePad como editor oredeterminado de programas VFP (defaultnotpadeditvfpprg.reg)
    Definir el lenguaje
    1. Ingrese a "NotePadd++"
    2. En el menú principal ingrese a "Lenguaje -> Definir idioma"
    3. En la ventana que desplegada presione el botón "Importar.." y seleccione el archivo "userDefineLang-VisualFoxPro-Jgoh.xml" en la ubicación en donde se descargo
    Con estos pasos ya se definió el lenguaje y cada uno de sus atributos. Cierre NotePad++ para asegurar que tome el nuevo lenguaje.

    Lista de funciones

    NotePad tiene la opción "Lista de funciones" (En el menú principal ingrese a "Vista -> Lista de funciones") la cual es útil cuando se abre un programa que contiene definiciones de Funciones o Procedimientos. Sin embargo como NotePad++ de forma nativa no tiene soporte para VFP es necesario agregar la configuración para dicha característica
    1. Ingrese al directorio %APPDATA%\notepad++\
    2. Edite el archivo functionList.xml con NotePad++
    3. En la sección <associationMap> adicione la siguiente linea al final:
      <association userDefinedLangName="Visual FoxPro" id="vfp_syntax"/>
    4. En la sección <parsers> adicione al final:
    5.    <parser id="vfp_syntax" displayName="VFP Classes & Functions" commentExpr="(t*!*)">
          <classRange
           mainExpr="^[t ]*((define class)[s]+)[w:]+[s]+as[s]+([w:]+)"
           closeSymbole = "^[t ]*enddefine"
           displayMode="node">
           <className>
            <nameExpr expr="[w:]+[s]+as[s]+([w:]+)"/>
           </className>
           <function
            mainExpr="^[t ]*((procedure|proc|function|func)[s]+)[w:]+[s]*[ (,)w]*">
            <functionName>
             <funcNameExpr expr="((procedure|proc|function|func)[s]+)[w:]+[s]*[ (,)w]*"/>
             <funcNameExpr expr="[s]+[w:]+[s]*[ (,)w]*"/>
             <funcNameExpr expr="[w:]+[s]*[ (,)w]*"/>
            </functionName>
           </function>
          </classRange>
      
          <function
           mainExpr="^[t ]*((procedure|proc|function|func)[s]+)[w:]+[s]*[ (,)w]*"
           displayMode="$functionName">
           <functionName>
            <funcNameExpr expr="((procedure|proc|function|func)[s]+)[w:]+[s]*[ (,)w]*"/>
            <funcNameExpr expr="[s]+[w:]+[s]*[ (,)w]*"/>
            <funcNameExpr expr="[w:]+[s]*[ (,)w]*"/>
           </functionName>
          </function>
         </parser>
      
    Guarde el archivo.

    NOTA: Si lo desea puede remplazar el archivo local functionList.xml por el que descargo

    NotePad++ como editor predeterminado de programas desde Visual FoxPro

    Usted puede predeterminar como editor de programas (*.prg) a NotePad desde la interfaz de FoxPro, para eso debemos crear el registro de windows la siguiente entrada
    [HKEY_CURRENT_USER\Software\Microsoft\VisualFoxPro\9.0\Options]
    "TEDIT"="/N C:\Program Files (x86)\Notepad++\notepad++.exe"
    NOTA: Si lo desea puede combinar el archivo defaultnotpadeditvfpprg.reg a su registro de windows presionando el botón derecho del ratón sobre el y seleccionando la opción "Combinar". recuerde que debe editar el archivo y cambiar la ruta del programa dependiendo de donde instalo NotePad.

    SCREENSHOT


    FUENTES
    Jose Guillermo Ortiz Hernandez