DBEDIT() 
 Visualiza registros en un formato de tabla
------------------------------------------------------------------------------
 Sintaxis

     DBEDIT([<nSup>], [<nIzq>],
        [<nInf>], [<nDer>],
        [<acColumnas>],
        [<cFunciónUsuario>],
        [<acPatronesFormatoSayColumna> | <cPatrónFormatoSayColumna>],
        [<acCabecerasColumna> | <cCabeceraColumna>],
        [<acSeparadoresCabecera> | <cSeparadorCabecera>],
        [<acSeparadoresColumna> | <cSeparadorColumna>],
        [<acSeparadoresPie> | <cSeparadorPie>],
        [<acPiesColumna> | <cPieColumna>]) --> NIL

 Argumentos

     <nSup>, <nIzq>, <nInf> y <nDer> definen las coordenadas
     de la parte superior izquierda e inferior derecha de la ventana
     DBEDIT(). Los valores de fila pueden ir de cero a MAXROW() y las
     posiciones de columna de cero a MAXCOL(). Si no se especifican, las
     coordenadas por defecto son 0, 0, MAXROW() y MAXCOL().

     <acColumnas> es una matriz de expresiones de caracteres que
     contiene nombres de campos de base de datos o expresiones para utilizar
     como valores de columna para cada columna que se muestra. Si no se
     especifica este argumento, DBEDIT() muestra todos los campos en el área
     de trabajo actual como columnas.

     <cFunciónUsuario> es el nombre de una función definida por el
     usuario, que se ejecuta cuando se pulsa una tecla irreconocible o no
     quedan teclas pendientes en la memoria intermedia de teclado.
     Especifique el nombre de función como una expresión de caracteres sin
     paréntesis ni argumentos. Recuerde que el funcionamiento de DBEDIT() se
     ve afectado por la presencia de este argumento. Consulte la descripción
     que se ofrece más adelante, si desea más información.

     <acPatronesFormatoSayColumna> es una matriz paralela de patrones
     para formatear cada columna. Si se especifica
     <cPatrónFormatoSayColumna> en lugar de una matriz, se muestran todas
     las columnas con el mismo formato. Si desea más información sobre
     patrones de formato, consulte TRANSFORM() o @...SAY.

     <acCabecerasColumna> es una matriz paralela de expresiones de
     caracteres, que define las cabeceras de cada columna. Si se especifica
     <cCabeceraColumna>, todas las columnas reciben el mismo encabezado. Si
     desea mostrar una cabecera de líneas múltiples, añada un punto y coma
     en la expresión de cabecera donde desea que se divida la cadena. Si no
     se especifica, las cabeceras de columna se toman de la matriz
     <acColumnas> o de los nombres de campo del área de trabajo actual si no
     se especifica el argumento <acColumnas>.

     <acSeparadoresCabeceras> es una matriz paralela de caracteres, que
     define los caracteres utilizados para dibujar líneas horizontales que
     separan las cabeceras de columnas del área de campos. Si se especifica
     <cSeparadorCabecera> en lugar de una matriz, se utiliza el mismo
     separador de cabeceras para todas las columnas. Si no se especifica
     este argumento, el separador por defecto es una línea doble.

     <acSeparadoresColumna> es una matriz paralela de expresiones de
     caracteres, que define los caracteres utilizados para dibujar las
     líneas verticales que separan las columnas. Si se especifica
     <cSeparadorColumna>, en lugar de una matriz se utiliza el mismo
     separador para todas las columnas. Si este argumento no se especifica,
     el separador por defecto es una línea simple.

     <acSeparadoresPie> es una matriz paralela de expresiones de
     caracteres, que define los caracteres utilizados para dibujar las
     líneas horizontales que separan los pies de columnas del área de
     campos. Si se especifica <cSeparadorPie> en lugar de una matriz, se
     utiliza el mismo separador de pie para todas las columnas. Si no se
     especifica este argumento, no existe separador de pie.

     <acPiesColumna> es una matriz paralela de expresiones de
     caracteres, que define los pies para cada columna. Si se especifica
     <cPieColumna> en lugar de una matriz, todas las columnas reciben el
     mismo pie. Para que se muestre un pie de líneas múltiples, añada un
     punto y coma en la expresión del pie donde desea que se divida la
     cadena. Si no se especifica este argumento, no existen pies de
     columna.

 Devuelve

     DBEDIT() devuelve siempre NIL.

 Descripción

     DBEDIT() es una función de interfaz de usuario y de compatibilidad que
     muestra registros de una o más áreas de trabajo en forma de tabla. La
     pantalla de la ventana DBEDIT() es una rejilla de celdas divididas en
     columnas y filas. Las columnas corresponden a los campos de base de
     datos y las filas corresponden a los registros de la base de datos.
     Cada columna se define mediante un elemento de la matriz <acColumnas>.
     La anchura de cada columna está determinada por la evaluación de la
     expresión de columna en la matriz <acColumnas> o el patrón de formato
     de columna especificado en la matriz <acPatronesFormatoSayColumna>.

     Todas las teclas de desplazamiento del cursor pueden utilizarse con
     DBEDIT(), incluyendo AvPág, RePág, Inicio, Fin, las cuatro teclas de
     flechas y todas las combinaciones de tecla con Ctrl que producen el
     desplazamiento del cursor. Las teclas de movimiento a las que responde
     DBEDIT() cuando no se especifica un argumento de función de usuario se
     listan en la tabla siguiente de teclas activas:

     Teclas Activas de DBEDIT()
     ------------------------------------------------------------------------
     Tecla                    Acción
     ------------------------------------------------------------------------
     Flecha Arriba            Sube una fila
     Flecha Abajo             Baja una fila
     Flecha Izquierda         Columna a la izquierda
     Flecha Derecha           Columna a la derecha
     Ctrl+Flecha Izquierda    Desplaza la visualización una columna a
                              la izquierda
     Ctrl+Flecha Derecha      Desplaza la visualización una columna a
                              la derecha
     Inicio                   Sitúa el cursor en la columna del
                              extremo izquierdo de la pantalla actual
     Fin                      Sitúa el cursor en la columna del
                              extremo derecho de la pantalla actual
     Ctrl+Inicio              Sitúa el cursor sobre la primera columna
                              de la tabla de visualización
     Ctrl+Fin                 Sitúa el cursor sobre la última columna
                              de la tabla de visualización
     RePág                    Pantalla anterior
     AvPág                    Pantalla siguiente
     Ctrl+RePág               Primera fila de la columna actual
     Ctrl+AvPág               Ultima fila de la columna actual
     Intro                    Finaliza DBEDIT()
     Esc                      Finaliza DBEDIT()
     ------------------------------------------------------------------------

     Cuando se especifica el argumento de función (<cFunciónUsuario>), todas
     las teclas indicadas en la tabla anterior están activas con excepción
     de Esc e Intro. Cuando DBEDIT() llama a la función de usuario, le pasa
     automáticamente dos argumentos:

      El modo actual, pasado como valor numérico

      El índice de la columna actual en <acColumnas>, pasado como un
        valor numérico

     El parámetro de modo indica el estado actual de DBEDIT(), según la
     última tecla ejecutada. Los valores de modo posibles se listan en la
     tabla siguiente:

     Modos DBEDIT()
     ------------------------------------------------------------------------
     Estado        Dbedit.ch      Descripción
     ------------------------------------------------------------------------
     0             DE_IDLE        Inactividad, se han procesado todas las
                                  pulsaciones de teclas de desplazamiento
                                  y no queda ninguna pendiente
     1             DE_HITTOP      Intenta desplazar el cursor antes del
                                  inicio del fichero
     2             DE_HITBOTTOM   Intenta situar el cursor después del
                                  final del fichero
     3             DE_EMPTY       No hay registros en el área de trabajo
     4             DE_EXCEPT      Excepción de teclado
     ------------------------------------------------------------------------

     El parámetro de índice apunta a la posición en la matriz <acColumnas>
     donde se encuentra la columna actual. Si no se especifica <acColumnas>,
     el parámetro de índice señala la posición del campo en la estructura de
     base de datos actual. Acceda al nombre de campo utilizando FIELD().

     La función definida por el usuario debe devolver un valor que indique a
     DBEDIT() la acción que debe ejecutar. En la tabla siguiente se listan
     los posibles valores de retorno y las acciones correspondientes:

     Valores de Retorno de Funciones de Usuario DBEDIT()
     ------------------------------------------------------------------------
     Valor         Dbedit.ch      Descripción
     ------------------------------------------------------------------------
     0             DE_ABORT       Cancela DBEDIT()
     1             DE_CONT        Continúa DBEDIT()
     2             DE_REFRESH     Fuerza a volver a leer y dibujar y
                                  continuar. Después de redibujar, procesa
                                  las teclas y queda inactivo
     ------------------------------------------------------------------------

     Existen varios casos en los que se invoca la función de usuario:

      Excepciones de teclado. Se producen cuando DBEDIT() recoge una
        pulsación de tecla que no reconoce. Cualquier tecla pendiente
        permanece en la memoria intermedia del teclado hasta que se recoge
        dentro de la función de usuario o hasta que DBEDIT() continúa.

      DBEDIT() entra en el modo inactivo (es decir, se han procesado
        todas las teclas pendientes). Se produce cuando el teclado está
        vacío o después de una actualización de pantalla. En este caso, se
        invoca la función del usuario y después DBEDIT() espera una
        pulsación.

      Se alcanza el principio o final del fichero. Es idéntico al
        estado inactivo. Se procesan todas las teclas ejecutables y se
        produce una llamada a la función de usuario con el mensaje de estado
        apropiado.

     Recuerde que cuando se ejecuta DBEDIT() por primera vez, todas las
     teclas pendientes en la memoria intermedia del teclado se ejecutan y,
     después, DBEDIT() queda en el modo inactivo e invoca la función de
     usuario. Si no quedan teclas pendientes, se pasa al modo inactivo
     inmediatamente.

     La función de usuario debe manejar todos los modos y mensajes de estado
     recibidos de DBEDIT().

     La función definida por el usuario debe asegurar que el estado de
     DBEDIT() sea equivalente al de DE_EXCEPT (4); de lo contrario, el valor
     de LASTKEY() carece de significado y el valor retorno de DE_REFRESH (2)
     sitúa la aplicación en un bucle sin fin. Por ejemplo:

     FUNCTION FuncEdicDB ( nModo, nPosColumna )
        LOCAL ValRet := DE_CONT

        IF ( nModo == DE_EXCEPT )
           IF ( LASTKEY() == K_F5 )
                  ValRet := DE_REFRESH
           ENDIF
        ENDIF
        RETURN( ValRet )

     DBEDIT() es una función reentrante, por lo que puede contener llamadas
     anidadas. Esta función permite utilizar simultáneamente múltiples
     ventanas de visualización.

     DBEDIT() es una función de compatibilidad, por lo que no es
     recomendable su utilización como función de visualización programable.
     Como tal, ha sido sustituida por la clase TBrowse. Si desea más
     información, consulte la clase TBrowse.

 Ejemplos

      Este ejemplo muestra una llamada genérica a DBEDIT():

        USE Nombres NEW
        DBEDIT()

      Este ejemplo muestra una llamada DBEDIT() con una función de
        usuario:

        #include "Dbedit.ch"
        #include "Inkey.ch"

        // La matriz debe ser visible a los otros
        // programas definidos en el programa

        STATIC acColumnas := {}

        PROCEDURE Main()

           USE Nombres NEW
           INDEX ON Nombres->Apellido + Nombres->Nombre TO Nombres

           CLS

           acColumnas := { "Apellido", "Nombre" }

           DBEDIT( 5, 5, 20, 70, acColumnas, "FuncUsuario" )

        RETURN


        FUNCTION FuncUsuario( nModo, nCol )
           LOCAL nTecla := LASTKEY()
           LOCAL nValRet := DE_CONT             // Valores de
                                                // retorno por defecto

           DO CASE
           CASE nModo == DE_IDLE
              nValRet := FuncInac()
           CASE nModo == DE_HITTOP
              TONE( 100, 3 )
           CASE nModo == DE_HITBOTTOM
              TONE( 100, 3 )
              nValRet := FuncAnex( nTecla )
           CASE nModo == DE_EMPTY
              nValRet := FuncVacia()
           CASE nModo == DE_EXCEPT
              nValRet := FuncExcep( nTecla, nCol )
           OTHERWISE
              TONE( 100, 3 )
           ENDCASE

        RETURN nValRet

        FUNCTION FuncAnex( nTecla )
           LOCAL nValRet := DE_CONT             // Valor de retorno
                                                // por defecto

           IF nTecla == K_DOWN                  // Si es la flecha Abajo
              APPEND BLANK                      // Añadir registro en blanco
        // Nota: El registro añadido aparecerá en la parte
        // superior de la ventana DBEDIT() en la que se indexa
        // la base de datos.

              nValRet := DE_REFRESH             // Actualizar pantalla
           ENDIF


        RETURN nValRet

        FUNCTION FuncExcep( nTecla, nCol )
           LOCAL nValRet := DE_CONT             // Valor de retorno por
                                                // defecto

           DO CASE
           CASE nTecla == K_ESC                 // Si ESC
              nValRet := DE_ABORT               // Salir
           CASE nTecla == K_RETURN              // Si RETURN
              nValRet := FuncEdit( nCol )       // Función para editar
                                                // campo

           // Activar/desactivar estado DELETED
           CASE nTecla == K_DEL .AND. LASTREC() != 0  // Pulsada
                                                      // tecla SUPR
              IF DELETED()
                  RECALL
              ELSE
                  DELETE
              ENDIF
           OTHERWISE
                  TONE( 100, 1 )
           ENDCASE

        RETURN nValRet


        FUNCTION FuncEdic( nCol )
           LOCAL cValIndice        // Valor de la expresión
                                   // clave actual
           LOCAL nValRet           // Valor de retorno
           LOCAL nCampo            // Posición del
                                   // campo actual
           LOCAL cValCampo         // Valor del campo actual
           LOCAL nGuardarCursor    // Conservar el estado
                                   // del cursor

           // Devuelve un error si no hay índice abierto
           cValIndice := &( INDEXKEY(0) )

           nCampo := FIELDPOS( acColumnas[nCol] )

           IF nCampo != 0
              nGuardarCursor := SETCURSOR()     // Guardar el estado
                                                // del cursor
              SETCURSOR(1)                      // Cambiar la forma
                                                // del cursor
              cValCampo := FIELDGET( nCampo )   // Guardar el
                                                // contenido
                                                // del campo
              @ ROW(), COL() GET cValCampo      // nuevo valor GET
              READ
              FIELDPUT( nCampo, cValCampo )     // Sustituir por
                                                // el nuevo valor
              SETCURSOR( nGuardarCursor )       // Restablecer
                                                // la forma del
                                                // cursor
           ENDIF


           IF cValIndice != &( INDEXKEY(0) )    // Si se modificó la
                                                // expresión clave,
           nSolicitud := DE_REFRESH             // actualizar
                                                // pantalla
           ELSE                                 // En caso contrario,
              nSolicitud := DE_CONT             // continuar
           ENDIF

        RETURN nSolicitud

        FUNCTION FuncInac()
           // Rutina de inactividad
        RETURN DE_CONT

        FUNCTION FuncVacia()
           // Rutina de registros vacíos
        RETURN DE_CONT

 Ficheros   La biblioteca asociada es EXTEND.LIB,
            los ficheros de cabecera son Dbedit.ch e Inkey.ch.
 To download this example - click here.

See Also: @...GET ACHOICE() BROWSE()* MEMOEDIT() READ