Notas
     ■ Configuración de teclas: Si se especifica una
        <cFunciónUsuario>, pueden configurarse las teclas que se incluyen en
        la siguiente tabla.

        Teclas configurables de MEMOEDIT()
        ---------------------------------------------------------------------
        Tecla                 Acción por Defecto
        ---------------------------------------------------------------------
        Ctrl+Y                Borra la línea actual
        Ctrl+T                Borra la palabra a la derecha
        Ctrl+B                Da formato al párrafo
        Ctrl+V/Ins            Cambia el modo de inserción
        Ctrl+W                Finaliza la edición guardando los cambios
        Esc                   Anula la edición devolviendo la cadena original
        ---------------------------------------------------------------------

        Si la tecla es configurable, al devolver 0 se ejecuta la acción por
        defecto de MEMOEDIT(). Sin embargo, si se devuelve un valor
        distinto se ejecuta otra acción que puede haber sido configurada. Si
        no se trata de una tecla configurable, también es posible asignarle
        una acción devolviendo un valor que corresponda a una de las
        acciones incluidas en la tabla anterior.

     ■ Salto automático de línea: El salto automático de línea es un
        modo de formato que puede cambiar devolviendo 34 desde la función de
        usuario. Si está seleccionado (opción por defecto), MEMOEDIT()
        inserta un retorno de carro/salto de línea automático en la
        finalización de palabra más cercana al borde de la ventana o al
        terminar la línea (lo que ocurra primero). Si no está seleccionado,
        MEMOEDIT() desplaza la memoria intermedia más allá del borde de la
        ventana, hasta que el cursor llegue al fin de línea. En ese punto,
        el usuario debe pulsar Intro (insertando un retorno de carro/salto
        de línea forzado) para pasar a la línea siguiente.

     ■ Formato de párrafos: Al pulsar Ctrl-B, o devolver 2 desde una
        función de usuario, se vuelve a formatear la memoria intermedia de
        texto hasta encontrar un retorno de carro forzado (fin de párrafo) o
        encontrar el final de la memoria intermedia de texto,
        independientemente de que el salto automático de línea esté
        seleccionado o no.

     ■ Retornos de carro automáticos: En CA-Clipper, la inserción de
        caracteres de retorno de carro/salto de línea automático nunca
        cambia el contenido significativo del texto. Es decir, cuando se
        inserta un retorno de carro/salto de línea automático entre dos
        palabras, se mantienen los caracteres de espacio que hay entre las
        dos palabras. Al cambiar el formato del texto, se eliminan todos los
        caracteres de retorno de carro/salto de línea automático. Esto deja
        el texto en su formato original y trata adecuadamente los casos en
        los que se ha insertado un retorno de carro/salto de línea
        automático en mitad de una palabra.

        En la función MEMOEDIT() de la versión Summer '87, al insertar un
        retorno de carro/salto de línea automático, se suprime un carácter
        de espacio en ese punto del texto. Si posteriormente se formatea el
        texto utilizando una anchura de línea diferente, todos los retornos
        de carro/saltos de línea automáticos se sustituyen por un espacio.
        Sin embargo, si la cadena de texto se formatea mediante alguna de
        las funciones de tratamiento de texto de CA-Clipper, las palabras
        que estaban separadas por un retorno de carro/salto de línea
        automático permanecen juntas, porque este carácter no se sustituye
        por un espacio.

        Para evitarlo, los textos formateados con la función MEMOEDIT()  de
        la versión Summer '87 deben procesarse para sustituir los caracteres
        de retorno de carro /salto de línea automático por espacios. Esto
        puede realizarse mediante la función STRTRAN(), tal como se indica a
        continuación:

        STRTRAN( <texto>, CHR(141)+CHR(10), " " )

        Para convertir los valores memo de una base de datos existente,
        puede utilizarse el siguiente programa de dos líneas:

        USE <xcBasedeDatos>
        REPLACE ALL <idMemo> WITH ;
        STRTRAN( <idMemo>, CHR(141)+CHR(10), " " )

        Debido al formato del fichero .dbt, la sustitución de todos los
        campos memo puede hacer que el fichero .dbt aumente notablemente. El
        fichero .dbt puede reducirse copiando el fichero .dbf en un nuevo
        fichero.

        En ficheros .dbt muy grandes, el procedimiento anterior puede no ser
        factible. En tal caso, puede utilizarse el programa DBT50.EXE,
        situado en el directorio \CLIP53\BIN. DBT50 examina un fichero .dbt
        completo, sustituyendo todos los pares de retorno de carro/salto de
        línea automático por dos espacios. Aunque esto produce el efecto no
        deseado de separar determinadas palabras con dos espacios en vez de
        uno, permite procesar el fichero directamente sin necesidad de
        utilizar espacio de disco adicional. DBT50 modifica únicamente los
        pares de caracteres de retorno de carro/salto de línea automático
        del fichero objeto. El resto del texto no se modifica.

     ■ Edición de ficheros de texto: MEMOEDIT() edita ficheros de
        texto si pueden leerse en una variable de caracteres de CA-Clipper.
        Esto puede hacerse mediante la función MEMOREAD(). Después de
        editar el contenido del fichero de texto incluido en la variable de
        caracteres, debe volver a escribirse en el fichero con MEMOWRIT().

 Ejemplos

      Este ejemplo permite examinar un campo memo, pero impide
        realizar cambios en la memoria intermedia de texto:

        USE Cliente NEW
        SET CURSOR OFF
        MEMOEDIT(NotasCli, 5, 10, 20, 69, .F.)
        SET CURSOR ON

      El siguiente ejemplo permite editar un campo memo, volviendo a
        asignar los cambios al mismo:

        USE Cliente NEW
        REPLACE NotasCli WITH ;
              MEMOEDIT(NotasCli, 5, 10, 20, 69)

      Este ejemplo crea una cadena de caracteres mediante
        MEMOEDIT():

        LOCAL cNotas
        cNotas = MEMOEDIT()

      El ejemplo siguiente es una función definida por el usuario
        que edita una cadena de caracteres en una ventana emmarcada, con un
        título:

        FUNCTION EditMemo( cCadena, cTitulo,;
                  nSup, nIzda, nInf, nDer )
           LOCAL cPantalla := SAVESCREEN(nSup nIzda,;
                  nInf, nDer)
           @ nSup - 1, nIzda - 2 CLEAR TO nInf + 1,;
                  nDer + 2
           @ nSup - 1, nIzda - 2 TO nInf + 1, nDer + 2
           @ nSup - 1, nIzda SAY "[" + cTitulo + "]"
           cCadena = MEMOEDIT(cCadena, nSup, nIzda,;
                  nInf, nDer)
           RESTSCREEN(nSup, nIzda, nInf, nDer, cPantalla)

           RETURN (cCadena)

      Este ejemplo lee el contenido de un fichero de texto incluido
        en una variable de caracteres, lo edita y lo vuelve a escribir en el
        disco:

        LOCAL cCadena := MEMOREAD("Texto.txt")
        cCadena := MEMOEDIT(cCadena)
        IF !MEMOWRIT("Texto.txt", cCadena)
           ? "Error de escritura"
           BREAK
        ENDIF
        RETURN

      Este ejemplo contiene una función definida por el usuario que
        muestra en pantalla un mensaje que describe el modo actual de
        MEMOEDIT(). Además, en el modo ME_UNKEY, la función realizará una
        acción ME_WORDRIGHT o ME_BOTTOMRIGHT, dependiendo de la tecla de
        función asociada que se haya pulsado:

        #include "Memoedit.ch"
        #include "Inkey.ch"

        PROCEDURE Main()
           USE Cliente NEW
           REPLACE NotasCli WITH;
           MEMOEDIT( NotasCli, 5, 5, 15, 75, .T., "MemoUDF" )
        RETURN

        FUNCTION MemoUDF( nModo, nLinea, nColumna )
           LOCAL nTecla := LASTKEY()
           LOCAL nValDev := ME_DEFAULT        // Acción devuelta por defecto
           DO CASE
           CASE nModo == ME_IDLE
              @ 20, 5 SAY "El modo es ME_IDLE "
           CASE nModo == ME_UNKEY
              @ 20, 5 SAY "El modo es ME_UNKEY "
              DO CASE
              CASE nTecla == K_F2
                  nValDev := ME_WORDRIGHT
              CASE nTecla == K_F3
                  nValDev := ME_BOTTOMRIGHT
              ENDCASE
              CASE nModo == ME_UNKEYX
              @ 20, 5 SAY "El modo es ME_UNKEYX"
           OTHERWISE
              @ 20, 5 SAY "El modo es ME_INIT "
           ENDCASE

        RETURN nValDev

 Ficheros   La biblioteca asociada es EXTEND.LIB,
            los ficheros de cabecera son Memoedit.ch e Inkey.ch.

 To download this example - click here.

See Also: HARDCR() LASTKEY() MEMOLINE() MEMOREAD() MEMOTRAN()