MEMOEDIT()
 Edita o visualiza campos memo o cadenas de caracteres
------------------------------------------------------------------------------
 Sintaxis

     MEMOEDIT([<cCadena>],
        [<nSup>], [<nIzq>], [<nInf>], [<nDer>],
        [<lModoEdición>],
        [<cFunciónUsuario>],
        [<nLongitudLínea>],
        [<nTamañoTabulador>],
        [<nFilaMemoInterTexto>],
        [<nColumnaMemoInterTexto>],
        [<nFilaVentana>],
        [<nColumnaVentana>]) --> cMemoInterTexto

 Argumentos

     <cCadena> es el campo memo o la cadena de caracteres que se va a
     copiar en la memoria intermedia de texto de MEMOEDIT(). Si no se
     especifica, la memoria intermedia de texto está vacía.

     <nSup>, <nIzq>, <nInf> y <nDer> son las coordenadas
     superior izquierda e inferior derecha, respectivamente, de la ventana.
     Los valores de fila pueden estar comprendidos entre cero y MAXROW() y
     los de columna entre cero y MAXCOL(). Si no se especifican, las
     coordenadas por defecto son 0, 0, MAXROW() y MAXCOL().

     <lModoEdición> determina si la memoria intermedia de texto puede
     editarse o sólo mostrarse en pantalla. Si se especifica el valor
     verdadero (.T.), el usuario puede modificar la memoria intermedia de
     texto. Si se especifica el valor falso (.F.), sólo puede visualizarla.
     El valor por defecto es verdadero (.T.).

     <cFunciónUsuario> es el nombre de una función definida por el
     usuario que se ejecuta cuando se pulsa una tecla no reconocida por
     MEMOEDIT() y cuando no quedan teclas pendientes en la memoria
     intermedia del teclado. <cFunciónUsuario> se especifica como valor de
     caracteres, sin paréntesis ni argumentos. Si se especifica el valor
     falso (.F.) en este argumento, se muestra en pantalla <cCadena> y se
     termina inmediatamente MEMOEDIT(). Este argumento modifica el
     comportamiento automático de MEMOEDIT(). Vea la explicación que se da
     más adelante.

     <nLongitudLínea> determina la longitud de las líneas mostradas en
     la ventana MEMOEDIT(). Si una línea es mayor que <nLongitudLínea>, el
     texto salta automáticamente a la línea siguiente de la ventana. Si
     <nLongitudLínea> es mayor que el número de columnas de la ventana, ésta
     se desplaza cuando el cursor sobrepasa el borde. Si no se especifica
     <nLongitudLínea>, la longitud de línea por defecto será (<nDer> -
     <nIzq>).

     <nTamañoTabulador> determina la parada de tabulador que se utiliza
     cuando se pulsa la tecla Tab. Si no se especifica, las paradas de
     tabulador se sitúan cada cuatro caracteres.

     <nFilaMemoInterTexto> y <nColumnaMemoInterTexto> definen la
     posición de visualización del cursor en la memoria intermedia de texto
     cuando se invoca a MEMOEDIT(). <nFilaMemoInterTexto> se numera a partir
     de uno (1) y <nColumnaMemoInterTexto> a partir de cero (0). Si no se
     especifican estos argumentos, el cursor se coloca en la fila uno (1) y
     columna cero (0) de la ventana MEMOEDIT().

     <nFilaVentana> y <nColumnaVentana> definen la posición inicial
     del cursor en la ventana MEMOEDIT(). Las filas y columnas se numeran a
     partir de cero (0). Si no se especifican estos argumentos, la posición
     inicial en la ventana es la fila cero (0) y la posición de columna
     actual del cursor.

 Devuelve

     MEMOEDIT() devuelve la memoria intermedia de texto si el usuario
     finaliza la edición con Ctrl+W o una copia de <cCadena> si finaliza con
     Esc.

 Descripción

     MEMOEDIT() es una función de interfaz de usuario y de edición de texto
     de propósito general, que permite editar campos memo y cadenas de
     caracteres largas. La edición se lleva a cabo en el área especificada,
     que puede estar situada en cualquier parte de la pantalla. Al igual
     que las demás funciones de interfaz de usuario, (ACHOICE() y DBEDIT()),
     MEMOEDIT() dispone de una serie de modos e incluye una función de
     usuario que permite la reconfiguración de las teclas y otras
     actividades relacionadas con la programación de las tareas actuales de
     edición de texto.

     ■ Memoria intermedia de texto: Cuando se utiliza MEMOEDIT()
        especificando <cCadena>, ésta se copia en la memoria intermedia de
        texto. El usuario edita realmente la memoria intermedia de texto. Si
        no se especifica <cCadena>, se muestra al usuario una memoria
        intermedia de texto vacía para su edición.

        Cuando el usuario sale de MEMOEDIT() pulsando Ctrl+W, se devuelve el
        contenido modificado de la memoria intermedia. Si sale pulsando Esc,
        se descarta la memoria intermedia de texto y se devuelve el valor
        de la <cCadena> original. En cualquier caso, el valor de retorno
        puede asignarse a un campo memo o a una variable, o pasarse como
        argumento a otra función.

     ■ Modos de edición: MEMOEDIT() utiliza dos modos de edición, que
        se controlan mediante el valor de <lModoEdición>. Si <lModoEdición>
        tiene el valor verdadero (.T.), MEMOEDIT() pasa al modo de edición y
        el usuario puede modificar la memoria intermedia de texto de
        MEMOEDIT(). Si <lModoEdición> tiene el valor falso (.F.), MEMOEDIT()
        pasa al modo de visualización y el usuario sólo puede desplazarse
        por la memoria intermedia, sin editarla ni poder insertar nuevo
        texto. Para facilitar la visualización, se ha modificado el
        desplazamiento de pantalla para que las flechas Arriba y Abajo suban
        o bajen el texto de la memoria intermedia una línea dentro de la
        ventana MEMOEDIT().

     ■ Introducción y edición de texto: En la función MEMOEDIT(), el
        usuario puede introducir y editar texto situando el cursor y
        añadiendo o borrando caracteres. Para facilitar la edición del
        texto, existen las siguientes teclas de desplazamiento y de
        edición:

        Teclas de desplazamiento y edición de MEMOEDIT()
        ---------------------------------------------------------------------
        Tecla                          Acción
        ---------------------------------------------------------------------
        Flecha Arriba/Ctrl+E           Sube una línea
        Flecha Abajo/Ctrl+X            Baja una línea
        Flecha Izquierda/Ctrl+S        Desplaza un carácter a la izquierda
        Flecha Derecha/Ctrl+D          Desplaza un carácter a la derecha
        Ctrl+Flecha Izquierda/Ctrl+A   Desplaza una palabra a la izquierda
        Ctrl+Flecha Derecha/Ctrl+F     Desplaza una palabra a la derecha
        Inicio                         Desplaza al principio de la línea
                                       actual
        Fin                            Desplaza al final de la línea actual
        Ctrl+Inicio                    Desplaza al principio de la ventana
                                       actual
        Ctrl+Fin                       Desplaza al final de la ventana actual
        RePág                          Desplaza a la ventana de edición
                                       anterior
        AvPág                          Desplaza a la siguiente ventana
                                       de edición
        Ctrl+RePág                     Desplaza al principio del memo
        Ctrl+AvPág                     Desplaza al final del memo
        Intro                          Desplaza al principio de la línea
                                       siguiente
        Suprimir                       Borra el carácter de la posición
                                       del cursor
        Retroceso                      Borra el carácter situado a la
                                       izquierda del cursor
        Tabulador                      Inserta un carácter de tabulador
                                       o espacios
        Carácter imprimible            Inserta ese carácter
        Ctrl+Y                         Borra la línea actual
        Ctrl+T                         Borra la palabra a la derecha
        Ctrl+B                         Da formato a un 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 y devuelve la
                                       cadena original
        ---------------------------------------------------------------------

        Para la introducción de texto existen dos modos: inserción y
        sobreescritura. Al invocar MEMOEDIT(), el modo por defecto es
        sobreescritura. Para cambiar el modo de edición puede pulsarse la
        tecla Ins, que intercambia los modos de inserción y sobreescritura.
        También puede cambiarse en una función de usuario utilizando
        READINSERT() o devolviendo 22. En el modo inserción, los caracteres
        se introducen en la posición actual del cursor en la memoria
        intermedia de texto, desplazando el resto del texto a la derecha. El
        modo inserción se indica en el área de la línea de estado. En el
        modo de sobreescritura, los caracteres se introducen en la posición
        actual del cursor sobreescribiendo los caracteres existentes, sin
        desplazar el resto de la memoria intermedia de texto.

        Según se introduce texto, cuando el cursor llega al borde de la
        ventana MEMOEDIT(), la línea actual salta a la línea siguiente de la
        memoria intermedia de texto y se inserta un retorno de carro
        automático (CHR(141)). Si se especifica un argumento
        <nLongitudLínea>, el texto salta cuando la posición del cursor
        coincide con <nLongitudLínea>. Si <nLongitudLínea> es mayor que la
        anchura de MEMOEDIT(), la ventana se desplaza al llegar el cursor al
        borde. Para iniciar explícitamente una nueva línea o párrafo, el
        usuario debe pulsar la tecla Intro.

     ■ Pantalla de edición: Cuando aparece en pantalla MEMOEDIT(),
        sobreescribe el área de la pantalla especificada sin guardar la
        pantalla subyacente. Tampoco muestra un borde o título. Para
        realizar estas acciones, debe crear un procedimiento o función que
        realice estas acciones y, luego, invocar MEMOEDIT(). Consulte el
        siguiente ejemplo.

     ■ Función de usuario: <cFunciónUsuario>, especificada como
        argumento, maneja las excepciones del teclado y reconfigura las
        teclas especiales. MEMOEDIT() invoca en distintas ocasiones a la
        función de usuario, normalmente como respuesta a teclas no
        reconocidas. Las teclas que producen excepciones del teclado son
        todas las teclas de control, teclas de función y teclas Alt. Como
        MEMOEDIT() no procesa estas teclas, es posible reconfigurarlas.
        Algunas de ellas tienen asignada una acción por defecto. Con la
        función de usuario pueden realizarse distintas acciones, dependiendo
        del modo actual de MEMOEDIT() y del valor de retorno que indica a
        MEMOEDIT() qué debe hacer a continuación.

        Cuando se especifica como argumento la función de usuario,
        MEMOEDIT() define dos clases de teclas: no configurables y
        excepciones del teclado. Cuando se pulsa una tecla no configurable,
        MEMOEDIT() la ejecuta. Por otra parte, cuando se genera una
        excepción del teclado se invoca a la función de usuario. Cuando en
        la memoria intermedia del teclado no quedan teclas para ser
        procesadas por MEMOEDIT(), se invoca de nuevo a la función de
        usuario.

        Cuando MEMOEDIT() llama a la función de usuario, le pasa
        automáticamente tres parámetros: el modo de MEMOEDIT(), la línea
        actual de la memoria intermedia de texto y la columna actual de la
        memoria intermedia de texto. El modo indica el estado actual de
        MEMOEDIT(), que depende de la última tecla pulsada o de la última
        acción realizada antes de ejecutar la función de usuario. A
        continuación se indican los modos posibles:

        Modos de MEMOEDIT()
        ---------------------------------------------------------------------
        Modo       Memoedit.ch    Descripción
        ---------------------------------------------------------------------
        0          ME_IDLE        Inactividad, se han procesado todas
                                  las teclas
        1          ME_UNKEY       Tecla desconocida, memo no se ha modificado
        2          ME_UNKEYX      Tecla desconocida, memo se ha modificado
        3          ME_INIT        Modo de inicialización
        ---------------------------------------------------------------------

        El modo 3 indica que MEMOEDIT() está en modo de inicialización. Al
        especificar <cFunciónUsuario>, MEMOEDIT() realiza una llamada a la
        función de usuario inmediatamente después de haberse invocado. En
        ese momento, la función de usuario debe devolver una petición para
        seleccionar los distintos modos de formato de texto de MEMOEDIT():
        salto automático de línea, desplazamiento de pantalla o inserción.
        MEMOEDIT() llama a la función de usuario varias veces,
        permaneciendo en el modo de inicialización hasta que la función de
        usuario devuelva 0. Entonces la memoria intermedia se muestra en
        pantalla y el usuario pasa al modo de edición seleccionado con
        <lModoEdición>. Recuerde que, si el salto automático de línea está
        activado cuando MEMOEDIT() pasa del modo de inicialización al de
        edición, toda la memoria intermedia de texto se formatea con
        <nLongitudLínea>. Para evitar esta acción de formato inicial,
        desactive el salto automático de línea durante la inicialización.
        Recuerde también que la activación/desactivación del desplazamiento
        y el salto automático de línea no están asignados inicialmente a
        ninguna tecla, pero pueden asignarse a una mediante la función de
        usuario.

        Los modos 1 y 2 indican que MEMOEDIT() ha recibido una tecla
        irreconocible o una tecla configurable de la memoria intermedia de
        teclado. Las teclas configurables se procesan devolviendo 0 para
        ejecutar la acción por defecto de MEMOEDIT(). Si se devuelve otro
        valor, se realiza otra acción, redefiniendo así la tecla. Si es una
        tecla irreconocible, puede asignársele una acción que devuelva un
        valor que solicite una acción del teclado o que realice una acción
        predefinida.

        El modo 0 indica que MEMOEDIT() está inactivo en ese momento porque
        no quedan teclas para procesar. Cuando MEMOEDIT() está inactivo, se
        invoca siempre la función de usuario. En ese momento, normalmente se
        actualizan las visualizaciones del número de línea y de columna.

        Los otros dos parámetros, línea y columna actuales, indican la
        posición actual del cursor en la memoria intermedia de texto al
        invocar la función de usuario. Los parámetros de línea se empiezan a
        contar en la posición uno (1) y los de columna en la posición cero
        (0).

        En los modos 1, 2 y 3, se puede devolver un valor que indique a
        MEMOEDIT() la siguiente acción que debe realizar. La tabla siguiente
        resume los posibles valores de retorno y sus consecuencias:

        Valores de retorno a la función de usuario de MEMOEDIT()
        ---------------------------------------------------------------------
        Valor      Memoedit.ch       Acción
        ---------------------------------------------------------------------
        0          ME_DEFAULT        Realiza la acción por defecto
        1-31       ME_UNKEY          Procesa la acción solicitada que
                                     corresponde al valor de la tecla
        32         ME_IGNORE         Ignora las teclas desconocidas
        33         ME_DATA           Trata las teclas desconocidas como
                                     datos
        34         ME_TOGGLEWRAP     Activa/desactiva el modo de salto
                                     automático de línea
        35         ME_TOGGLESCROLL   Activa/desactiva el modo de
                                     desplazamiento de pantalla
        100        ME_WORDRIGHT      Se desplaza una palabra a la derecha
        101        ME_BOTTOMRIGHT    Se desplaza al final del texto
        ---------------------------------------------------------------------

     ■ Ficheros de cabecera: Para facilitar la memorización y
        utilización de los valores de modo y de petición, existe en
        \CLIP53\INCLUDE un fichero de cabecera llamado Memoedit.ch. Además,
        en el mismo directorio existe Inkey.ch, que contiene las constantes
        declaradas para todos los valores de INKEY().

 To download this example - click here.

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