Cómo usar Componentes de texto en java SWING

JTextComponent y sus descendientes implementan los componentes de texto editable de Swing. La siguiente figura muestra la herencia de los componentes de texto y los grupos de clases de acuerdo a sus capacidades:

Los componentes de texto puro (text field, password field, y text area) son los componentes más fáciles y comúnmente utilizados. En unas pocas líneas de código podemos fácilmente, crear, configurar y usar un componente de texto plano en nuestro programa. Los componentes que pueden mostrar texto con estilos (editor pane y text pane) normalmente requieren algo más de esfuerzo para utilizarlos. La mayoría de los programadores utilizan editor pane o text pane cuando necesitan construir un interface que le permita al usuario cambiar los estilos de texto. También, la obtención del contendido de un componente de texto con estilos requiere más código que una simple llamada a getText.

Pero, como muestra el diagrama, tanto los componentes de texto plano como los de texto con estilo descienden de JTextComponent. Esta clase abstracta proporciona una base poderosa y altamente configurable para la manipulación de textos. JTextComponent proporciona estas características personalizables para todos sus descendientes:

• Separación de documentos (el modelo de la división, modelo/vista) para manejar el contenido del componente.
• Capacidades de edición expresadas a través de comandos acción.
• Mapas de teclado personalizables y uniones de teclas.
• Soporte para deshacer/repetir infinito.
• Cursor de texto conectable y soporte para oyentes de caret (cursor).

La aplicación mostrada abajo contiene un textpane personalizado y un interface de usuario para interactuar con él:

El área de texto inferior es un log que reporta todos los cambios hechos en el texto del textpane. La línea de estado de la parte inferior de la ventana informa sobre la localización de la selección o de la posición del cursor de texto, dependiendo de si hay texto seleccionado.

---

Nota: El fichero fuente de esta aplicación es TextComponentDemo.java. También necesitarás LimitedStyledDocument.java. Podrías necesitar Seleccionar el proxy en la línea de comandos para ejecutar este programa.

---

A través de esta aplicación de ejemplo, aprenderemos como usar las capacidades de los componentes de texto y como personalizarlas. Esta sección cubre estos tópicos:

• Trabajar con un Documento de un Componente de Texto
• Escuchar los Cambios en un Documento
• Adjuntar controles GUI a los Comandos de Edición de Texto
• Sobre los Kits de Editores
• Modificar el Mapa de Teclado por Defecto
• Implementar Deshacer y Repetir
• Escuchar Caret y Selection Changes
• Mostrar texto desde una URL
• El API Text
• Ejemplos que usan componentes de Texto

Puedes visitar la siguiente página , Cómo usar Text Fields para más información sobre text fields y password fields.

Trabajar con un Documento de un Componente de Texto

Al igual que muchos otros componentes Swing, los componentes de texto separan su contenido de su visión. El contenido de un componente de texto está manejado por sudocumento, que contiene el texto, soporta su edición y notifica a los oyentes los cambios en el texto. Un documento es un ejemplar de una clase que implementa el interfaceDocument o su subinterface StyledDocument.La aplicación mostrada anteriormente tiene un documento personalizado, LimitedStyledDocument, que limita el número de caracteres que puede contener.LimitedStyledDocument es una subclase de DefaultStyledDocument, el documento por defecto para JEditorPane y JTextPane.
Aquí está el código del programa que crea un LimitedStyledDocument y lo hace el documento del textpane:

...where the member variables are declared...
JTextPane textPane;
static final int MAX_CHARACTERS = 200;
    ...in the constructor for the frame...
    //Create the document for the text area
    LimitedStyledDocument lpd = new LimitedStyledDocument(
      MAX_CHARACTERS);
    ...
    //Create the text pane and configure it
    textPane = new JTextPane();
    ...
    textPane.setDocument(lpd);

Para limitar los caracteres permitidos en el documento, LimitedStyledDocument sobreescribe el método insertString de su superclase, que es llamado cada vez que se inserta texto en el documento.

public void insertString(int offs, String str, AttributeSet a)
               throws BadLocationException {
    if ((getLength() + str.length()) <= maxCharacters)
        super.insertString(offs, str, a);
    else
        Toolkit.getDefaultToolkit().beep();
}

Además de insertString, los documentos personalizados normalmente sobreescriben el método remove, que es llamado cada vez que se elimina texto del documento.Otro uso común de un documento personalizado, es crear un validador de pulsaciones para un campo de texto (un campo cuyo valor es chequeado cada vez que es editado.

Escuchar los Cambios en un Documento

Un documento notifica los cambios a los oyentes interesados. Se utiliza un oyente de 'document' para realizar una acción cuando se ha insertado o eliminado texto de un documento, o cuando el estilo o algo del texto haya cambiado.El programa TextComponentDemo utiliza un oyente de 'document' par actualizar el log de cambios siempre que se haga un cambio en el textpane. Esta línea de código registra un ejemplar de MyDocumentListener como un oyente de LimitedStyledDocument usado en el ejemplo:

LimitedStyledDocument lpd = new LimitedStyledDocument(MAX_CHARACTERS);
lpd.addDocumentListener(new MyDocumentListener());

Aquí está la implementación de MyDocumentListener:

protected class MyDocumentListener implements DocumentListener {
    public void insertUpdate(DocumentEvent e) {
        update(e);
    }
    public void removeUpdate(DocumentEvent e) {
        update(e);
    }
    public void changedUpdate(DocumentEvent e) {
        AbstractDocument.DefaultDocumentEvent de =
        (AbstractDocument.DefaultDocumentEvent)e;
        //Display the type of edit that occurred
        changeLog.append(de.getPresentationName() + newline);
    }
    private void update(DocumentEvent e) {
        AbstractDocument.DefaultDocumentEvent de =
        (AbstractDocument.DefaultDocumentEvent)e;
        //Display the type of edit that occurred and
        //the resulting text length              
        changeLog.append(de.getPresentationName() +
           ": text length = " +
           e.getDocument().getLength() + newline);
    }
} 

El oyente de nuestro ejemplo muestra el tipo del cambio que ha ocurrido, y si es afectada por el cambio, la longitud del texto. Para información general sobre los oyentes de document y los eventos document, puedes ver la página Cómo escribir un oyente de Document.Recuerda que la documentación de este textpane limita el número de caracteres permitidos en el documento. Si intentamos añadir texto hasta exceder el máximo, el documento bloquea el cambio y no se llama al método insertUpdate del oyente. Los oyentes de document sólo son notificados si el cambio ha ocurrido realmente.
Algunas veces, podríamos intentar cambiar el texto del documento desde dentro de un oyente de document. Por ejemplo, si tenemos un textfield que debería contener sólo enteros y el usuario introduce cualquier otro tipo de dato, podríamos querer cambiar el texto a 0. Sin embargo, nunca se debe cambiar el contenido de un componente de texto desde dentro de un oyente de document. De hecho, si intentamos hacerlo, nuestro programa se quedará bloqueado! En su lugar debemos proporcionar un documento personalizado y sobreescribir los métodos insert y remove. Crear un TextField Validado muestra cómo hacerlo.

Adjuntar Controles GUI a los Comandos de Edición de Texto

Un componente de texto Swing soporta comandos de edición estándard como cortar, copiar y pegar. Cada comando de edición está representado e implementado por un objeto action. Esto hace sencillo el adjuntar un control GUI como un ítem de menú o unbotón, a un comando y construir un GUI alrededor de un componente de texto.Text fields, password fields, y text areas manejan sus propios conjuntos de acciones. En contraste, JEditorPane y JTextPane usan un ejemplar de EditorKit para manejar sus conjuntos de acciones. Para información conceptual sobre los kits de editores, puedes ver la próxima sección, Sobre los Kits de Editor. Por ahora, sólo necesitas saber que un kit de editor contiene una colección de acciones para un editorpane o un textpane.
Se utiliza el método getActions sobre nuestro componente de texto o sobre el kit de editor para obtener un array con todas las acciones soportadas por un componente de texto particular. Es conveniente cargar el array de acciones en un Hashtable para que nuestro programa pueda recuperar una acción por el nombre. Aquí está el código deTextComponentDemo que obtiene las acciones desde el textpane y las carga dentro de un Hashtable:

private Hashtable createActionTable(JTextComponent textComponent) {
    Hashtable actions = new Hashtable();
    Action[] actionsArray = textComponent.getActions();
    for (int i = 0; i < actionsArray.length; i++) {
        Action a = actionsArray[i];
        actions.put(a.getValue(Action.NAME), a);
    }
    return actions;
}    

Y aquí tenemos un método de conveniencia para recuperar una acción por su nombre desde el hashtable:

private Action getActionByName(String name) {
    return (Action)(actions.get(name));
}

Se puede copiar el primer método sin modificar en nuestro programa. Para el segundo método, tenemos que cambiar actions por el nombre de nuestro hashtable.Ahora veamos como se crea un ítem de menú Cut y cómo se adjunta a la acción para eliminar texto del componente.

protected JMenu createEditMenu() {
    JMenu menu = new JMenu("Edit");
    ...
    Action action = getActionByName(DefaultEditorKit.cutAction);
    action.putValue(Action.NAME, "Cut");
    menu.add(action);
    ...

Este código obtiene la acción por su nombre, le cambia el nombre a algo sencillo y añade la acción al menú. Esto es todo lo que tenemos que hacer. El menú y la action tienen cuidado de todo lo demás. Habrás observado que el nombre de la acción viene de DefaultEditorKit. Este es el kit de editor por defecto utilizado por editorpane para tratar con texto plano. Este proporciona acciones para la edición de texto básica.Configurar el menú Style es algo similar, excepto en que los comandos vienen de otro kit de editor. Aquí está elcódigo que crea el menú y le pone el ítem Bold:

protected JMenu createStyleMenu() {
    JMenu menu = new JMenu("Style");
 
    Action action = new StyledEditorKit.BoldAction();
    action.putValue(Action.NAME, "Bold");
    menu.add(action);
    ...

El StyledEditorKit es el kit editor por defecto para un textpane. Comprende un formato de texto rico y personalizado (llamado ("Tim's Rich Text Format") y proporciona subclases Action para implementar comandos de edición. Por eso éste crea un ejemplar de la clase BoldAction, le cambia el nombre y la pone en el menú.Además e adjuntar controles GUI a un comando action, también podemos unir una pulsación de tecla con una acción. Modificar el Mapa de Teclado por Defecto muestra como hacerlo.

Sobre los Kits de Editor

Esta sección proporciona alguna información conceptual sobre los kits de editores y expresa la potencia que le dan a un editorpane.Junto al manejo de un conjunto de acciones para un componente de texto, un kit de editor sabe cómo leer y escribir documentos en un formato particular. El paquete de texto de Swing proporciona kits de editores para texto plano, Tim's Rich Text Format, HTML, y RTF.

DefaultEditorKit

Lee y escribe texto sin exilos. Proporciona un conjunto básico de comandos de edición. Este es el kit de editor usado por defecto por editorpane cuando se carga texto plano o texto de un formato desconocido.

StyledEditorKit

Lee y escribe Tim's Rich Text Format y proporciona un conjunto mínimo de acción para estilos de texto. Esta clase es una subclase de DefaultEditorKit. Este el el kit de editor usado por JTextPane.

HTMLEditorKit

Lee, escribe y edita HTML. Esta es una subclase de StyledEditorKit.

RTFEditorKit

Lee, escribe y edita RTF. Esta es una subclase de StyledEditorKit.

Cada uno de estos kits de editor han sido registrados con la clase JEditorPane y asociados con el formato de texto que comprenden. Cuando se carga un fichero dentro de un editorpane, el panel chequea el formato con sus kits registrados. Si encuentra un kit que soporta el formato del fichero, el panel lo utiliza para leerlo, mostrarlo y editarlo. Así, el editorpane se transforma a sí mismo en un editor para ese formato de texto.Podemos extender JEditorPane para que soporte nuestro propio formato de texto craando un kit de editor y utilizando el método registerEditorKitForContentType deJEditorPane para asociar e kit con nuestro formato de texto.

Modificar el Mapa de Teclado por Defecto

Todo componente de texto tiene uno o más keymaps (Mapa de teclado)-- cada uno ellos es un ejemplar de la clase Keymap. Un mapa de telcado contiene una colección de parejas nombre-valor donde el nombre es una pulsación de tecla y el valor es una Action. Cada pareja une la pulsación con la acción para que cuando el usuario pulsa las teclas ocurra la acción.Por defecto, un componente de texto tiene un mapa de teclado llamado JTextComponent.DEFAULT_KEYMAP. Este mapa de teclado contiene uniones de teclas estándards y básicas. Por ejemplo, la tecla 'f' del teclado está mapeada a la acción de introducir el caracter 'f' en el componente de texto, las telclas de flechas están mapeadas para mover el punto de inserción, etc. Si necesitamos cambiar las uniones por defecto, normalmente ampliaremos o modificaremos el mapa de teclado por defecto de una de estas formas:

• Añadir un mapa de teclado personalizado al componente de de texto con el método addKeymap de JTextComponent.
• Añadir uniones de teclas al mapa de teclado por defecto con el método addActionForKeyStroke de Keymap.
• Elimar uniones de teclas del mapa de teclado por defecto con el método removeKeyStrokeBinding de Keymap.

La mayoría de los programas no reemplazan completamente el mapa de teclado por defecto.Cuando se resuelve una pulsación a su acción, el componente de texto chequea el mapa de teclado para añadirlo al componente de texto. Así, la unión para una puslación específica en un mapa de teclado que queramos añadir al componente de texto sobreescribe cualquier unión para la misma pulsación que hubiera en el mapa de teclado por defecto.
El textpane de TextComponentDemo añade cuatro uniones de teclas al mapa de teclado por defecto.

• CTRL-B para mover el cursor de insercción un carácter hacia atrás.
• CTRL-F para mover el cursor de inserción un carácter hacui adelante.
• CTRL-P para mover el cursor de inserción una línea hacia arriba.
• CTRL-N para mover el cursor de inserción una línea hacia abajo.

El siguiente código añade la unión de teclas CTRL-B al mapa de teclado por defecto. El código para añadir los otros tres es similar.

//Get the current, default map
Keymap keymap = textPane.getKeymap();

//Ctrl-b to go backward one character
Action action = getActionByName(DefaultEditorKit.backwardAction);
KeyStroke key = KeyStroke.getKeyStroke(KeyEvent.VK_B, Event.CTRL_MASK);
keymap.addActionForKeyStroke(key, action);

El código, primero obtiene el mapa de teclado actual. Luego obtiene la opción 'ir atrás' del kit de editor y obtiene un objeto KeyStroke que representa la secuencia CTRL-B. Finalmente, el código añade la pareja action-keystroke al mapa de teclado, por lo tanto une la tecla a la acción.

Implementar Deshacer y Repetir

---

Nota:La implementación de deshacer y repetir de TextComponentDemo fue copiada directamente del programa de demostración NotePad que viene con Swing. Muchos programadores también podrán copiar esta implementación sin modificaciones.

---

La implementación deshacer/repetir tiene dos partes:

• Recordar la edición reversible que ha ocurrido.
• Implementar los comandos deshacer y repetir y proporcionar un interface de usuario para ellos.

Parte 1: Recordar Ediciones Reversibles
Para soportar deshacer/repetir, un componente de texto debe recordar cada edición que ha ocurrido en él, el orden en que una edición ocurre en relación a otra, y lo que toma para deshacerlas. El programa de ejemplo usa un manejador de deshacer, un ejemplar de la clase UndoManager del paquete undo de Swing, para menejar su lista de ediciones reversibles. Este manejador se crea donde se declaran las variables miembro:

protected UndoManager undo = new UndoManager();

Ahora, veamos como el programa encuentra las ediciones reversibles y las añade al manejador.Un documento notifica a los oyentes interesados si ha ocurrido una edición reversible en su contenido. Un paso importante en la implementación de deshacer/repetir es registar un oyente de 'undoable edit' con el documento del componente de texto. Este código añade un ejemplar de MyUndoableEditListener al documento del textpane:

lpd.addUndoableEditListener(new MyUndoableEditListener());

El oyente de 'undoable edit' usado en nuestro ejemplo añade la edición a la lista del manejador de deshacer (undo):

protected class MyUndoableEditListener implements UndoableEditListener {
    public void undoableEditHappened(UndoableEditEvent e) {
        //Remember the edit and update the menus
        undo.addEdit(e.getEdit());
        undoAction.update();
        redoAction.update();
    }
}  

Observa que este método actualiza dos objetos undoAction y redoAction. Estos son los objetos action adjuntados a los ítems de menú Undo (Deshacer) y Redo(Repetir), respectivamente. El siguiente paso muestra cómo se cran los ítems de menú y la implementación de las dos acciónes.Para información general sobre oyentes de ' undoable edit' y eventos 'undoable edit', puedes ver la página Cómo escribir un Oyente de Undoable Edit.
Parte 2: Implementar los Comandos Deshacer/Repetir
El primer paso de esta parte de implementar deshacer y repetir es crear las acciones y ponerlas en el menú Edit.

JMenu menu = new JMenu("Edit");

//Undo and redo are actions of our own creation
undoAction = new UndoAction();
menu.add(undoAction);

redoAction = new RedoAction();
menu.add(redoAction);
...

Las acciones deshacer y repetir están implementadas por las subclases de AbstractAction: UndoAction y RedoAction respectivamente. Estas clases son clases internas de la clase principal del ejemplo.Cuando un usuario invoca al comando Undo, se llama al método actionPerformed de UndoAction:

public void actionPerformed(ActionEvent e) {
    try {
        undo.undo();
    } catch (CannotUndoException ex) {
        System.out.println("Unable to undo: " + ex);
        ex.printStackTrace();
    }
    update();
    redoAction.update();
}

Este método llama al método undo del manejador de deshacer y actualiza los ítems de menú para que reflejen el nuevo estado.De forma similar cuando el usuario llama al comando Repetir, se llama al método actionPerformed en RedoAction:

public void actionPerformed(ActionEvent e) {
    try {
        undo.redo();
    } catch (CannotRedoException ex) {
        System.out.println("Unable to redo: " + ex);
        ex.printStackTrace();
    }
    update();
    undoAction.update();
}

Este método es similar excepto en que llama al método redo del manejador de deshacer.La mayoría del código de las clases UndoAction y RedoAction esta dedicado a activar y desactivar las acciones de forma apropiada para el estadoa actual, y cambiar los nombres de los ítems de menú para reflejar le edición a ser desecha o repetida.

Escuchar Caret y Selection Changes

El programa TextComponentDemo usa un oyente de 'caret' para mostrar la posición actual del punto de inserción o si hay texto seleccionado, la extensión de la selección.El oyente de 'caret' es también una etiqueta. Aquí está el código que crea la etiqueta, la añade a la ventana y la hace el oyente de 'caret' del textpane:

//Create the status area
JPanel statusPane = new JPanel(new GridLayout(1, 1));
CaretListenerLabel caretListenerLabel = new CaretListenerLabel(
      "Caret Status");
statusPane.add(caretListenerLabel);
...
textPane.addCaretListener(caretListenerLabel);

Un oyente de 'caret' debe implementar un método, caretUpdate, que es llamado cada vez que el cursor de inserción se mueve o la selección cambia. Aquí está la implementación que hace CaretListenerLabel del método caretUpdate:

public void caretUpdate(CaretEvent e) {
    //Get the location in the text
    int dot = e.getDot();
    int mark = e.getMark();
    if (dot == mark) {  // no selection
        try {
            Rectangle caretCoords = textPane.modelToView(dot);
            //Convert it to view coordinates
            setText("caret: text position: " + dot +
                    ", view location = [" +
                    caretCoords.x + ", " + caretCoords.y + "]" +
                    newline);
        } catch (BadLocationException ble) {
            setText("caret: text position: " + dot + newline);
        }
     } else if (dot < mark) {
        setText("selection from: " + dot + " to " + mark + newline);
     } else {
        setText("selection from: " + mark + " to " + dot + newline);
     }
}

Como has podido ver, este oyente actualiza el texto de su etiqueta para reflejar el estado actual del punto de inserción o de la selección. El oyente obtiene la información mostrada del objeto 'event caret'. Para información general sobre los oyentes de 'caret' y los 'eventos caret', puedes ver la página Cómo escribir un Oyente de Caret.Al igual que los oyentes de 'document', un oyente de 'caret' es pasivo. Reacciona a los cambios en el punto de inserción o en la selección pero no los cambia. En vez de modificar el punto de inserción y la selección desde un oyente de 'caret', se debería utilizar un 'caret' personalizado. Para crear uno, se debe escribir una clase que implemente el interface Caret, y luego proporcionar un ejemplar de nuestra clase como un argumento a setCaret sobre el componente de texto.

Mostrar Texto de una URL

Al arrancar, el textpane de TextComponentsDemo contiene texto. El programa utiliza setPage para cargar un fichero HTML en el textpane. Aquí está el código:

//Load the text area with text
try {
    URL url = new URL("http://java.sun.com/docs/books/tutorial/ui/" +
        "swing/example-swing/TextComponentDemo.html");
    textPane.setPage(url);
} catch (Exception e ) {
    System.err.println("Can't open instructions");
}

JTextPane hereda el método setPage de su clase padre JEditorPane. La versión de setPage usada en este ejemplo toma un objeto URL como parámetro. Otra versión de este método requiere un String especificando una URL. La URL puede especificar un fichero HTML, RTF, o de texto plano.

El API de Texto

Esta sección proporciona estas tablas de APIs de los componentes de texto:

• Clases de Componentes de Texto Swing
• Métodos de JTextComponent para Seleccionar Atributos
• Convertir Posiciones entre el Modelo y la Vista
• Clases e Interfaces que representan Documentos
• Métodos Útiles para Trabajar con Documentos
• Métodos de JTextComponent para Manipular la Selección Actual
• Manipular Cursores de Inserción e Indicadores de Selección
• Comandos de Edición de Texto
• Unir Pulsaciones de Teclas y Acciones
• Leer y Escribir Texto
• API para Mostrar Texto desde una URL

Clases de Componentes de Texto Swing

Clase	Descripción
JTextComponent	La superclase abstracta de todos los componentes de texto Swing.
JTextField	Un componente de texto plano, de una sóla línea y opcionalmente editable.
JPasswordField	Un componente de texto plano, de una sóla línea y opcionalmente editable que enmascara su contenido.
JTextArea	Un componente de texto plano, multi-línea y opcionalmente editable.
JEditorPane	Un componente de texto con estilo, multi-línea y opcionalmente editable.
JTextPane	Un componente de texto con estilo, multi-línea y opcionalmente editable que soporta nombres de atributos.

Métodos de JTextComponent para Seleccionar Atributos

Método	Descripción
void setDisabledTextColor(Color) Color getDisabledTextColor()	Selecciona u obtiene el color usado para mostrar el texto cuando el componente de texto esta desactivado.
void setOpaque(boolean) boolean getOpaque()	Selecciona u obtiene si el componente de texto es completamente opaco.
void setMargin(Insets) Insets getMargin()	Selecciona u obtiene el margen entre el texto y el borde del componente.
void setEditable(boolean) boolean isEditable()	Selecciona u obtiene si el usuario puede editar el texto que hay en el componente.

Convertir Posiciones entre el Modelo y la Vista

Método	Descripción
int viewToModel(Point) (en JTextComponent)	Convierte el punto específico del sistema de coordenadas de la vista en una posición específica dentro del texto.
Rectangle modelToView(int) (en JTextComponent)	Convierte la posición del texto especificada en un rectángulo en el sistema de coordenadas de la vista.

Clases e Interfaces que Representan Documentos

Interface o Clase	Descripción
Document (un interface)	Define el API que debe ser implementado en todos los documentos.
AbstractDocument (un interface)	Una implementación de la superclase abstracta del interfae Document. Esta es la superclase de todos los documentos porporcionados por el paquete de texto de Swing.
PlainDocument (una clase)	Implementa el interface Document. El documento por defecto para los componentes de texto plano (text field, password field, y text area). Además la usan editor pane y text pane cuando cargan texto plano o texto en un formato desconocido.
StyledDocument (un interface)	Un subinterface de Document. Describe el API que deben implementar todos los documentos que soporten texto con estilos.
DefaultStyledDocument (una clase)	Implementa el interface StyledDocument. El documento por defecto para los componentes de texto con estilo (editor pane y text pane).

Métodos Útiles para Trabajar con Documentos

Método	Descripción
setDocument(Document) Document getDocument() (en JTextComponent.)	Selecciona u obtiene el documento para un componente de texto.
Document createDefaultModel() (en JTextField.)	Sobreescribe este método en un textfield y sus subclases para crear un documento personalizado en vez delPlainDocument por defecto.
void insertString(int, String, AttributeSet) void remove(int, int) (in Document)	Estos métodos normalmente se sobreescriben para crear documentos personalizados.
void addDocumentListener(DocumentListener) void removeDocumentListener(DocumentListener) (en Document)	añade o elimina un oyente de 'document' a un documento.
void addUndoableEditListener(UndoableEditListener) void removeUndoableEditListener(UndoableEditlistener) (en Document)	Añade o elimina un oyente de 'undoable edit' a un documento.
int getLength() Position getStartPosition() Position getEndPosition() String getText(int, int) (en Document)	Métodos de Document que devuelven información útil sobre el documento.
Object getProperty(Object) void putProperty(Object, Object) (en Document) Dictionary getDocumentProperties() void setDocumentProperties(Dictionary) (en AbstractDocument)	Un Document mantiene un conjunto de propiedades que podemos manipular con estos métodos.

Métodos de JTextComponent para Manipular la Selección Actual

Método	Descripción
String getSelectedText()	Obtiene el texto seleccionado actualmente.
void selectAll() void select(int, int)	Selecciona todo el texto o selecciona el texto dentro del rango indicado.
void setSelectionStart(int) void setSelectionEnd(int) int getSelectionStart() int getSelectionEnd()	Selecciona u obtiene la extensión de la selección actual por el índice.
void setSelectedTextColor(Color) Color getSelectedTextColor()	Selecciona u obtiene el color del texto seleccionado.
void setSelectionColor(Color) Color getSelectionColor()	Selecciona u obtiene el color del fondo del texto seleccionado.

Manipular el Cursor de Inserción y la Indicación de Selección

Interface, Clase, o Método	Descripción
Caret (un interface)	Define el API para los objetos que representan un punto de inserción dentro de los documentos.
DefaultCaret (una clase)	El cursor de texto utilizado para todos los componentes de texto.
void setCaret(Caret) Caret getCaret() (en JTextComponent)	Selecciona u obtiene el objeto caret usado por un componente de texto.
void setCaretColor(Color) Color getCaretColor() (en JTextComponent)	Selecciona u obtiene el color del cursor de texto.
void setCaretPosition(Position) void moveCaretPosition(int) Position getCaretPosition() (en JTextComponent)	Selecciona u obtiene la posición actual del cusor de texto dentro del documento.
void addCaretListener(CaretListener) void removeCaretListener(CaretListener) (en JTextComponent)	Añade o elimina un oyente de caret de un componente de texto.
Highlighter (un interface)	Define el API para objetos que se usan para iluminar la selección actual.
DefaultHighlighter (una clase)	El iluminador por defecto usado por todos los componentes de texto.
void setHighlighter(Highlighter) Highlighter getHighlighter() (en JTextComponent)	Selecciona u obtiene el iluminador usado por un componente de texto.

Comandos de Edición de Texto

Clase o Método	Descripción
void cut() void copy() void paste() void replaceSelection(String) (en JTextComponent)	Cortar, copiar y pegar texto usando el sistema del portapapeles.
EditorKit (unaa clase)	Edita, lee y escribe texto en un formato particular.
DefaultEditorKit (una clase)	Una subclase concreta de EditorKit que proporciona capacidades básicas de edición de texto.
StyledEditorKit (una clase)	Una subclase de Default EditorKit que proporciona capacidades adicionales de edición para texto con estilos.
String xxxxAction (en DefaultEditorKit)	Los nombres de todas las acciones soportadas por el kit de editor por defecto.
BeepAction CopyAction CutAction DefaultKeyTypedAction InsertBreakAction InsertContentAction InsertTabAction PasteAction (en DefaultEditorKit)	Una colección de clases internas que implementan varios comandos de edición de texto.
AlignmentAction BoldAction FontFamilyAction FontSizeAction ForegroundAction ItalicAction StyledTextAction UnderlineAction (en StyledEditorKit)	Una colecciónde clases internas que implementan varios comandos de edición de texto con estilos.
Action[] getActions() (en JTextComponent)	Obtiene las acciones soportadas por este componente. Este método obtiene un array de acciones del kit de editor que es utilizado por el componente.

Uniones de Teclas y Acciones

Interface o Método	Descripción
Keymap (un interface)	Un interface para manejar un conjunto de uniones de teclas. Las uniones están representadas por parejas keystroke/action.
Keymap addKeymap(nm, Keymap) Keymap removeKeymap(nm) Keymap getKeymap(nm) (en JTextComponent)	Añade o elimina un mapa de teclado del árbol de teclado. También obtiene el nombre del mapa de teclado. Observa que estos son métodos de clase. El árbol del mapa de teclado es compartido por todos los componentes de texto.
void loadKeymap(Keymap, KeyBinding[], Action[]) (en JTextComponent)	Añade un conjunto de uniones al mapa de teclado especificado. Es un método de clase.
void setKeymap(Keymap) Keymap getKeymap() (en JTextComponent)	Selecciona u obtiene el mapa de teclado atual para un componente de texto particular.
void addActionForKeyStroke(KeyStroke, Action) Action getAction(KeyStroke) KeyStroke[] getKeyStrokesForAction(Action) (en Keymap)	Selecciona u obtiene una unión keystroke/action desde un mapa de teclado.
boolean isLocallyDefined(KeyStroke) (en Keymap)	Obtiene si la pulsación indicada tiene una acción en el mapa de teclado.
void removeKeyStrokeBinding(KeyStroke) void removeBindings() (en Keymap)	Elimina una o tadas las uniones de teclas de un mapa de teclado.
void setDefaultAction(Action) Action getDefaultAction() (en Keymap)	Selecciona u obtiene la acción por defecto. esta acción se dispara si una pulsación no encuentra su acción.
Action[] getBoundActions() KeyStroke[] getBoundKeyStrokes() (en Keymap)	Obtiene un array que contiene todas las acciones y pulsaciones del mapa de teclado.

Leer y Escribir Texto

Método	Descripción
void JTextComponent.read(Reader, Object) void JTextComponent.write(Writer) (en JTextComponent)	Lee o escribe texto.
void read(Reader, Document, int) void read(InputStream, Document, int) (en EditorKit)	Lee texto desde un Stream a un documento.
void write(Writer, Document, int, int) void write(OutputStream, Document, int, int) (en EditorKit)	Escribe texto desde un documento a un Stream.

API para Mostrar Texto desde una URL

Método o Constructor	Descripción
JEditorPane(URL) JEditorPane(String) (en JEditorPane)	Crea un editor pane cargado con el texto de la URL especificada.
setPage(URL) setPage(String) (en JEditorPane)	Carga un editor pane (o text pane) con el texto de la URL especificada.
URL getPage() (en JEditorPane)	Obtiene la URL de la página actual del editor pane (o del text pane).

Ejemplos que usan componentes de texto

Esta tabla muestra algunos ejemplos que usan componentes de texto y dónde encontralos.

Ejemplo	Dónde se describe	Notas
TextDemo.java		Usa un textfield y un textarea básicos.
TextComponentDemo.java	Esta página	Proprorciona un textpane personalizado. Ilustra muchas características de los componentes de texto.
TextFieldDemo.java	Cómo usar TextField	Implementa dos textfields con validación de puslaciones.
PasswordDemo.java	Cómo usar Text Field y Usar SwingWorkerClass	Usa un password field
ToolBarDemo2.java	Cómo usar ToolBars	Pone un campo de texto en un barra de herramientas.
CustomDialog.java	Cómo usar Diálogos	Pone un textfield validado en un diálogo.
TreeDemo.java	Cómo usar Trees	Usa un editor pane para mostrar ayuda cargada desde un fichero HTML.

---