READ
 Activa el modo de edición de pantalla completa utilizando objetos Get
------------------------------------------------------------------------------
 Sintaxis

     READ [SAVE] [MENU <oMenu>] [MSG AT <nFila>, <nIzq>,
        <nDer>] [MSG COLOR <cCadenaColor>]

 Argumentos

     SAVE conserva el contenido de la GetList actual tras finalizar el
     mandato READ. Estos objetos Get pueden editarse más tarde ejecutando
     otro mandato READ. Si no se especifica, se asigna a la GetList actual
     una matriz vacía, borrando todos los objetos Get anteriores al
     finalizar el mandato READ.

     MENU <oMenu> representa un objeto TopBarMenu opcional que, cuando
     se especifica, permite seleccionar una opción de menú durante la
     entrada de datos.

     MSG AT <nFila>, <nIzq>, <nDer> especifica la fila y los
     márgenes izquierdo y derecho del área de la pantalla donde se
     visualizan los mensajes del objeto Get. Si se omite, no aparecen
     mensajes en pantalla.

     MSG COLOR <cCadenaColor> define los atributos de color del área de
     mensaje. Está formada por un par de atributos que determinan el color
     de primer término y de fondo.

 Descripción

     READ activa el modo de edición de pantalla completa usando todos los
     objetos Get creados y añadidos a la GetList actual desde los últimos
     mandatos CLEAR, CLEAR GET, CLEAR ALL o READ. Si hay algún procedimiento
     de formato activo, READ ejecuta ese procedimiento antes de entrar en el
     modo de edición de pantalla completa.

     Con el mandato READ, el usuario puede editar la memoria intermedia de
     cada objeto Get, así como moverse de un objeto Get a otro. Antes de que
     el usuario pueda entrar en un objeto Get, el control pasa a la
     <CondiciónPrevia> asociada a la cláusula WHEN si hay alguna asignada al
     objeto Get. Si la <CondiciónPrevia> devuelve el valor verdadero (.T.),
     el usuario puede editar la memoria intermedia del objeto. En caso
     contrario, el control pasa al siguiente objeto Get de la GetList. Al
     editar la memoria intermedia de un GET, el usuario puede utilizar todas
     las teclas de desplazamiento y edición. Consulte las tablas
     siguientes.

     Al pulsar una tecla de salida, se evalúa la condición RANGE o VALID
     asociada, si se ha especificado alguna. Si alguna condición devuelve el
     valor verdadero (.T.), la edición del objeto Get finaliza y el control
     pasa al siguiente objeto Get. En caso contrario, el control permanece
     en el objeto Get actual hasta que se introduzca un valor válido o hasta
     que el usuario pulse la tecla Esc.

     Cuando el usuario introduce un valor correcto en un objeto Get, se
     asigna a la variable asociada el valor existente en la memoria
     intermedia del objeto.

     Las tablas siguientes listan las teclas utilizables con un mandato
     READ:

     Teclas de desplazamiento del mandato READ
     ------------------------------------------------------------------------
     Tecla                                        Acción
     ------------------------------------------------------------------------
     Flecha izquierda, Ctrl+S                     Carácter a la izquierda.
                                                  No mueve el cursor al GET
                                                  anterior
     Flecha derecha, Ctrl+D                       Carácter a la derecha.
                                                  No mueve el cursor al
                                                  siguiente GET
     Ctrl+Flecha izquierda, Ctrl+A                Palabra a la izquierda
     Ctrl+Flecha derecha, Ctrl+F                  Palabra a la derecha
     Flecha arriba, Mayús+Tab, Ctrl+E             GET anterior
     Flecha abajo, Tab, Ctrl+X, Intro, Ctrl+M     GET siguiente
     Inicio                                       Primer carácter del GET
     Fin                                          Ultimo carácter del GET
     Ctrl+Inicio                                  Comienzo del primer GET
     ------------------------------------------------------------------------

     Teclas de edición del mandato READ
     ------------------------------------------------------------------------
     Tecla                                        Acción
     ------------------------------------------------------------------------
     Supr, Ctrl+G                                 Borra el carácter de la
                                                  posición del cursor
     Retroceso, Ctrl+H                            Borra el carácter anterior
     Ctrl+T                                       Borra la palabra de la
                                                  derecha
     Ctrl+Y                                       Borra desde la posición del
                                                  cursor hasta el final del
                                                  objeto GET
     Ctrl+U                                       Restablece el valor
                                                  original en el objeto
                                                  GET actual
     ------------------------------------------------------------------------

     Teclas de activación/desactivación del mandato READ
     ------------------------------------------------------------------------
     Tecla                                        Acción
     ------------------------------------------------------------------------
     Ins, Ctrl+V                                  Activa/desactiva el modo
                                                  de inserción
     ------------------------------------------------------------------------

     Teclas de salida del mandato READ
     ------------------------------------------------------------------------
     Tecla                                        Acción
     ------------------------------------------------------------------------
     Ctrl+W, Ctrl+C, RePág, AvPág                 Finaliza el READ y guarda
                                                  el GET actual
     Intro, Ctrl+M                                Finaliza el READ desde el
                                                  último GET
     Esc                                          Finaliza el READ sin
                                                  guardar el GET actual
     Flecha arriba                                Finaliza el READ desde el
                                                  primer GET si
                                                  READEXIT()=.T.
     Flecha abajo                                 Finaliza el READ desde el
                                                  último objeto GET si
                                                  READEXIT()=.T.
     ------------------------------------------------------------------------

 Notas

     ■ Mandatos READ anidados: Para anidar un READ en un
        procedimiento o función definida por el usuario SET KEY, VALID o
        WHEN, declare o cree una nueva GetList, escriba una serie de
        sentencias @...GET y, a continuación, ejecute el mandato READ. Al
        finalizar el procedimiento, la nueva GetList se libera y la GetList
        anterior se hace nuevamente visible. Consulte el ejemplo siguiente.

     ■ Teclas rápidas: Pulsando las teclas Inicio o Fin se pasa al
        primer o último carácter que no esté en blanco de la memoria
        intermedia del objeto Get.

     ■ Finalización de un mandato READ: El mandato READ finaliza al
        ejecutar BREAK, CLEAR, CLEAR GET o CLEAR ALL desde un procedimiento
        SET KEY o una función definida por el usuario iniciada mediante la
        cláusula VALID.

     ■ UPDATED(): Si se ha modificado la memoria intermedia de un
        objeto Get durante el mandato READ actual, UPDATED() devuelve el
        valor verdadero (.T.).

 Ejemplos

      Este ejemplo define varios GET y, a continuación, ejecuta
        READ:

        CLEAR
        cVar1 := cVar2 := cVar3 := SPACE(10)
        @ 10, 10 SAY "Variable uno:" GET cVar1 VALID ;
              !EMPTY(cVar1)
        @ 11, 10 SAY "Variable dos:" GET cVar2 ;
                  WHEN RTRIM(cVar1) != "Uno"
        @ 12, 10 SAY "Variable tres:" GET cVar3 VALID ;
                  !EMPTY(cVar3)
        READ

      Este ejemplo anida un READ en un procedimiento o función
        definida por el usuario SET KEY, WHEN o VALID:

        LOCAL cNombre := SPACE(10)
        @ 10, 10 GET cNombre VALID SubForm(cNombre)
        READ
        RETURN

        FUNCTION SubForm(cConsulta)
           LOCAL GetList := {}          // Crea una nueva GetList
           USE Ventas INDEX Vendedor NEW
           SEEK cConsulta
           IF FOUND()
           @ 15, 10 GET Vendedor        // Añade objetos Get
           @ 16, 10 GET Importe         // a la nueva GetList
           READ                         // READ con la nueva GetList
           ENDIF
           CLOSE Ventas
           RETURN .T.                        // Libera la nueva GetList

 Ficheros   La biblioteca asociada es CLIPPER.LIB.

 To download this example - click here.

See Also: @...GET @...SAY CLEAR GETS LASTKEY() READEXIT()