StyledEditorKit.java

/*
 * Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation. Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
packagejavax.swing.text;

importjava.io.*;
importjava.awt.*;
importjava.awt.event.ActionEvent;
importjava.beans.PropertyChangeEvent;
importjava.beans.PropertyChangeListener;
importjavax.swing.event.*;
importjavax.swing.Action;
importjavax.swing.JEditorPane;
importjavax.swing.KeyStroke;
importjavax.swing.UIManager;

/**
 * This is the set of things needed by a text component
 * to be a reasonably functioning editor for some <em>type</em>
 * of text document. This implementation provides a default
 * implementation which treats text as styled text and
 * provides a minimal set of actions for editing styled text.
 *
 * @author Timothy Prinzing
 */
@SuppressWarnings("serial") // Same-version serialization only
publicclassStyledEditorKitextendsDefaultEditorKit {

/**
 * Creates a new EditorKit used for styled documents.
 */
publicStyledEditorKit() {
createInputAttributeUpdated();
createInputAttributes();
 }

/**
 * Gets the input attributes for the pane. When
 * the caret moves and there is no selection, the
 * input attributes are automatically mutated to
 * reflect the character attributes of the current
 * caret location. The styled editing actions
 * use the input attributes to carry out their
 * actions.
 *
 * @return the attribute set
 */
publicMutableAttributeSetgetInputAttributes() {
returninputAttributes;
 }

/**
 * Fetches the element representing the current
 * run of character attributes for the caret.
 *
 * @return the element
 */
publicElementgetCharacterAttributeRun() {
returncurrentRun;
 }

// --- EditorKit methods ---------------------------

/**
 * Fetches the command list for the editor. This is
 * the list of commands supported by the superclass
 * augmented by the collection of commands defined
 * locally for style operations.
 *
 * @return the command list
 */
publicAction[] getActions() {
returnTextAction.augmentList(super.getActions(), defaultActions);
 }

/**
 * Creates an uninitialized text storage model
 * that is appropriate for this type of editor.
 *
 * @return the model
 */
publicDocumentcreateDefaultDocument() {
returnnewDefaultStyledDocument();
 }

/**
 * Called when the kit is being installed into
 * a JEditorPane.
 *
 * @param c the JEditorPane
 */
publicvoidinstall(JEditorPanec) {
c.addCaretListener(inputAttributeUpdater);
c.addPropertyChangeListener(inputAttributeUpdater);
Caretcaret = c.getCaret();
if (caret != null) {
inputAttributeUpdater.updateInputAttributes
 (caret.getDot(), caret.getMark(), c);
 }
 }

/**
 * Called when the kit is being removed from the
 * JEditorPane. This is used to unregister any
 * listeners that were attached.
 *
 * @param c the JEditorPane
 */
publicvoiddeinstall(JEditorPanec) {
c.removeCaretListener(inputAttributeUpdater);
c.removePropertyChangeListener(inputAttributeUpdater);

// remove references to current document so it can be collected.
currentRun = null;
currentParagraph = null;
 }

/**
 * Fetches a factory that is suitable for producing
 * views of any models that are produced by this
 * kit. This is implemented to return View implementations
 * for the following kinds of elements:
 * <ul>
 * <li>AbstractDocument.ContentElementName
 * <li>AbstractDocument.ParagraphElementName
 * <li>AbstractDocument.SectionElementName
 * <li>StyleConstants.ComponentElementName
 * <li>StyleConstants.IconElementName
 * </ul>
 *
 * @return the factory
 */
publicViewFactorygetViewFactory() {
returndefaultFactory;
 }

/**
 * Creates a copy of the editor kit.
 *
 * @return the copy
 */
publicObjectclone() {
StyledEditorKito = (StyledEditorKit)super.clone();
o.currentRun = o.currentParagraph = null;
o.createInputAttributeUpdated();
o.createInputAttributes();
returno;
 }

/**
 * Creates the AttributeSet used for the selection.
 */
privatevoidcreateInputAttributes() {
inputAttributes = newSimpleAttributeSet() {
publicAttributeSetgetResolveParent() {
return (currentParagraph != null) ?
currentParagraph.getAttributes() : null;
 }

publicObjectclone() {
returnnewSimpleAttributeSet(this);
 }
 };
 }

/**
 * Creates a new <code>AttributeTracker</code>.
 */
privatevoidcreateInputAttributeUpdated() {
inputAttributeUpdater = newAttributeTracker();
 }


privatestaticfinalViewFactorydefaultFactory = newStyledViewFactory();

ElementcurrentRun;
ElementcurrentParagraph;

/**
 * This is the set of attributes used to store the
 * input attributes.
 */
MutableAttributeSetinputAttributes;

/**
 * This listener will be attached to the caret of
 * the text component that the EditorKit gets installed
 * into. This should keep the input attributes updated
 * for use by the styled actions.
 */
privateAttributeTrackerinputAttributeUpdater;

/**
 * Tracks caret movement and keeps the input attributes set
 * to reflect the current set of attribute definitions at the
 * caret position.
 * <p>This implements PropertyChangeListener to update the
 * input attributes when the Document changes, as if the Document
 * changes the attributes will almost certainly change.
 */
@SuppressWarnings("serial") // JDK-implementation class
classAttributeTrackerimplementsCaretListener, PropertyChangeListener, Serializable {

/**
 * Updates the attributes. <code>dot</code> and <code>mark</code>
 * mark give the positions of the selection in <code>c</code>.
 */
voidupdateInputAttributes(intdot, intmark, JTextComponentc) {
// EditorKit might not have installed the StyledDocument yet.
DocumentaDoc = c.getDocument();
if (!(aDocinstanceofStyledDocument)) {
return ;
 }
intstart = Math.min(dot, mark);
// record current character attributes.
StyledDocumentdoc = (StyledDocument)aDoc;
// If nothing is selected, get the attributes from the character
// before the start of the selection, otherwise get the attributes
// from the character element at the start of the selection.
Elementrun;
currentParagraph = doc.getParagraphElement(start);
if (currentParagraph.getStartOffset() == start || dot != mark) {
// Get the attributes from the character at the selection
// if in a different paragraph!
run = doc.getCharacterElement(start);
 }
else {
run = doc.getCharacterElement(Math.max(start-1, 0));
 }
if (run != currentRun) {
/*
 * PENDING(prinz) All attributes that represent a single
 * glyph position and can't be inserted into should be
 * removed from the input attributes... this requires
 * mixing in an interface to indicate that condition.
 * When we can add things again this logic needs to be
 * improved!!
 */
currentRun = run;
createInputAttributes(currentRun, getInputAttributes());
 }
 }

publicvoidpropertyChange(PropertyChangeEventevt) {
ObjectnewValue = evt.getNewValue();
Objectsource = evt.getSource();

if ((sourceinstanceofJTextComponent) &&
 (newValueinstanceofDocument)) {
// New document will have changed selection to 0,0.
updateInputAttributes(0, 0, (JTextComponent)source);
 }
 }

publicvoidcaretUpdate(CaretEvente) {
updateInputAttributes(e.getDot(), e.getMark(),
 (JTextComponent)e.getSource());
 }
 }

/**
 * Copies the key/values in <code>element</code>s AttributeSet into
 * <code>set</code>. This does not copy component, icon, or element
 * names attributes. Subclasses may wish to refine what is and what
 * isn't copied here. But be sure to first remove all the attributes that
 * are in <code>set</code>.<p>
 * This is called anytime the caret moves over a different location.
 *
 * @param element the element
 * @param set the attributes
 */
protectedvoidcreateInputAttributes(Elementelement,
MutableAttributeSetset) {
if (element.getAttributes().getAttributeCount() > 0
 || element.getEndOffset() - element.getStartOffset() > 1
 || element.getEndOffset() < element.getDocument().getLength()) {
set.removeAttributes(set);
set.addAttributes(element.getAttributes());
set.removeAttribute(StyleConstants.ComponentAttribute);
set.removeAttribute(StyleConstants.IconAttribute);
set.removeAttribute(AbstractDocument.ElementNameAttribute);
set.removeAttribute(StyleConstants.ComposedTextAttribute);
 }
 }

// ---- default ViewFactory implementation ---------------------

staticclassStyledViewFactoryimplementsViewFactory {

publicViewcreate(Elementelem) {
Stringkind = elem.getName();
if (kind != null) {
if (kind.equals(AbstractDocument.ContentElementName)) {
returnnewLabelView(elem);
 } elseif (kind.equals(AbstractDocument.ParagraphElementName)) {
returnnewParagraphView(elem);
 } elseif (kind.equals(AbstractDocument.SectionElementName)) {
returnnewBoxView(elem, View.Y_AXIS);
 } elseif (kind.equals(StyleConstants.ComponentElementName)) {
returnnewComponentView(elem);
 } elseif (kind.equals(StyleConstants.IconElementName)) {
returnnewIconView(elem);
 }
 }

// default to text display
returnnewLabelView(elem);
 }

 }

// --- Action implementations ---------------------------------

privatestaticfinalAction[] defaultActions = {
newFontFamilyAction("font-family-SansSerif", "SansSerif"),
newFontFamilyAction("font-family-Monospaced", "Monospaced"),
newFontFamilyAction("font-family-Serif", "Serif"),
newFontSizeAction("font-size-8", 8),
newFontSizeAction("font-size-10", 10),
newFontSizeAction("font-size-12", 12),
newFontSizeAction("font-size-14", 14),
newFontSizeAction("font-size-16", 16),
newFontSizeAction("font-size-18", 18),
newFontSizeAction("font-size-24", 24),
newFontSizeAction("font-size-36", 36),
newFontSizeAction("font-size-48", 48),
newAlignmentAction("left-justify", StyleConstants.ALIGN_LEFT),
newAlignmentAction("center-justify", StyleConstants.ALIGN_CENTER),
newAlignmentAction("right-justify", StyleConstants.ALIGN_RIGHT),
newBoldAction(),
newItalicAction(),
newStyledInsertBreakAction(),
newUnderlineAction()
 };

/**
 * An action that assumes it's being fired on a JEditorPane
 * with a StyledEditorKit (or subclass) installed. This has
 * some convenience methods for causing character or paragraph
 * level attribute changes. The convenience methods will
 * throw an IllegalArgumentException if the assumption of
 * a StyledDocument, a JEditorPane, or a StyledEditorKit
 * fail to be true.
 * <p>
 * The component that gets acted upon by the action
 * will be the source of the ActionEvent if the source
 * can be narrowed to a JEditorPane type. If the source
 * can't be narrowed, the most recently focused text
 * component is changed. If neither of these are the
 * case, the action cannot be performed.
 * <p>
 * <strong>Warning:</strong>
 * Serialized objects of this class will not be compatible with
 * future Swing releases. The current serialization support is
 * appropriate for short term storage or RMI between applications running
 * the same version of Swing. As of 1.4, support for long term storage
 * of all JavaBeans
 * has been added to the <code>java.beans</code> package.
 * Please see {@link java.beans.XMLEncoder}.
 */
@SuppressWarnings("serial") // Same-version serialization only
publicabstractstaticclassStyledTextActionextendsTextAction {

/**
 * Creates a new StyledTextAction from a string action name.
 *
 * @param nm the name of the action
 */
publicStyledTextAction(Stringnm) {
super(nm);
 }

/**
 * Gets the target editor for an action.
 *
 * @param e the action event
 * @return the editor
 */
protectedfinalJEditorPanegetEditor(ActionEvente) {
JTextComponenttcomp = getTextComponent(e);
if (tcompinstanceofJEditorPane) {
return (JEditorPane) tcomp;
 }
returnnull;
 }

/**
 * Gets the document associated with an editor pane.
 *
 * @param e the editor
 * @return the document
 * @throws IllegalArgumentException for the wrong document type
 */
protectedfinalStyledDocumentgetStyledDocument(JEditorPanee) {
Documentd = e.getDocument();
if (dinstanceofStyledDocument) {
return (StyledDocument) d;
 }
thrownewIllegalArgumentException("document must be StyledDocument");
 }

/**
 * Gets the editor kit associated with an editor pane.
 *
 * @param e the editor pane
 * @return the kit
 * @throws IllegalArgumentException for the wrong document type
 */
protectedfinalStyledEditorKitgetStyledEditorKit(JEditorPanee) {
EditorKitk = e.getEditorKit();
if (kinstanceofStyledEditorKit) {
return (StyledEditorKit) k;
 }
thrownewIllegalArgumentException("EditorKit must be StyledEditorKit");
 }

/**
 * Applies the given attributes to character
 * content. If there is a selection, the attributes
 * are applied to the selection range. If there
 * is no selection, the attributes are applied to
 * the input attribute set which defines the attributes
 * for any new text that gets inserted.
 *
 * @param editor the editor
 * @param attr the attributes
 * @param replace if true, then replace the existing attributes first
 */
protectedfinalvoidsetCharacterAttributes(JEditorPaneeditor,
AttributeSetattr, booleanreplace) {
intp0 = editor.getSelectionStart();
intp1 = editor.getSelectionEnd();
if (p0 != p1) {
StyledDocumentdoc = getStyledDocument(editor);
doc.setCharacterAttributes(p0, p1 - p0, attr, replace);
 }
StyledEditorKitk = getStyledEditorKit(editor);
MutableAttributeSetinputAttributes = k.getInputAttributes();
if (replace) {
inputAttributes.removeAttributes(inputAttributes);
 }
inputAttributes.addAttributes(attr);
 }

/**
 * Applies the given attributes to paragraphs. If
 * there is a selection, the attributes are applied
 * to the paragraphs that intersect the selection.
 * if there is no selection, the attributes are applied
 * to the paragraph at the current caret position.
 *
 * @param editor the editor
 * @param attr the attributes
 * @param replace if true, replace the existing attributes first
 */
protectedfinalvoidsetParagraphAttributes(JEditorPaneeditor,
AttributeSetattr, booleanreplace) {
intp0 = editor.getSelectionStart();
intp1 = editor.getSelectionEnd();
StyledDocumentdoc = getStyledDocument(editor);
doc.setParagraphAttributes(p0, p1 - p0, attr, replace);
 }

 }

/**
 * An action to set the font family in the associated
 * JEditorPane. This will use the family specified as
 * the command string on the ActionEvent if there is one,
 * otherwise the family that was initialized with will be used.
 * <p>
 * <strong>Warning:</strong>
 * Serialized objects of this class will not be compatible with
 * future Swing releases. The current serialization support is
 * appropriate for short term storage or RMI between applications running
 * the same version of Swing. As of 1.4, support for long term storage
 * of all JavaBeans
 * has been added to the <code>java.beans</code> package.
 * Please see {@link java.beans.XMLEncoder}.
 */
@SuppressWarnings("serial") // Same-version serialization only
publicstaticclassFontFamilyActionextendsStyledTextAction {

/**
 * Creates a new FontFamilyAction.
 *
 * @param nm the action name
 * @param family the font family
 */
publicFontFamilyAction(Stringnm, Stringfamily) {
super(nm);
this.family = family;
 }

/**
 * Sets the font family.
 *
 * @param e the event
 */
publicvoidactionPerformed(ActionEvente) {
JEditorPaneeditor = getEditor(e);
if (editor != null) {
Stringfamily = this.family;
if ((e != null) && (e.getSource() == editor)) {
Strings = e.getActionCommand();
if (s != null) {
family = s;
 }
 }
if (family != null) {
MutableAttributeSetattr = newSimpleAttributeSet();
StyleConstants.setFontFamily(attr, family);
setCharacterAttributes(editor, attr, false);
 } else {
UIManager.getLookAndFeel().provideErrorFeedback(editor);
 }
 }
 }

privateStringfamily;
 }

/**
 * An action to set the font size in the associated
 * JEditorPane. This will use the size specified as
 * the command string on the ActionEvent if there is one,
 * otherwise the size that was initialized with will be used.
 * <p>
 * <strong>Warning:</strong>
 * Serialized objects of this class will not be compatible with
 * future Swing releases. The current serialization support is
 * appropriate for short term storage or RMI between applications running
 * the same version of Swing. As of 1.4, support for long term storage
 * of all JavaBeans
 * has been added to the <code>java.beans</code> package.
 * Please see {@link java.beans.XMLEncoder}.
 */
@SuppressWarnings("serial") // Same-version serialization only
publicstaticclassFontSizeActionextendsStyledTextAction {

/**
 * Creates a new FontSizeAction.
 *
 * @param nm the action name
 * @param size the font size
 */
publicFontSizeAction(Stringnm, intsize) {
super(nm);
this.size = size;
 }

/**
 * Sets the font size.
 *
 * @param e the action event
 */
publicvoidactionPerformed(ActionEvente) {
JEditorPaneeditor = getEditor(e);
if (editor != null) {
intsize = this.size;
if ((e != null) && (e.getSource() == editor)) {
Strings = e.getActionCommand();
try {
size = Integer.parseInt(s, 10);
 } catch (NumberFormatExceptionnfe) {
 }
 }
if (size != 0) {
MutableAttributeSetattr = newSimpleAttributeSet();
StyleConstants.setFontSize(attr, size);
setCharacterAttributes(editor, attr, false);
 } else {
UIManager.getLookAndFeel().provideErrorFeedback(editor);
 }
 }
 }

privateintsize;
 }

/**
 * An action to set foreground color. This sets the
 * <code>StyleConstants.Foreground</code> attribute for the
 * currently selected range of the target JEditorPane.
 * This is done by calling
 * <code>StyledDocument.setCharacterAttributes</code>
 * on the styled document associated with the target
 * JEditorPane.
 * <p>
 * If the target text component is specified as the
 * source of the ActionEvent and there is a command string,
 * the command string will be interpreted as the foreground
 * color. It will be interpreted by called
 * <code>Color.decode</code>, and should therefore be
 * legal input for that method.
 * <p>
 * <strong>Warning:</strong>
 * Serialized objects of this class will not be compatible with
 * future Swing releases. The current serialization support is
 * appropriate for short term storage or RMI between applications running
 * the same version of Swing. As of 1.4, support for long term storage
 * of all JavaBeans
 * has been added to the <code>java.beans</code> package.
 * Please see {@link java.beans.XMLEncoder}.
 */
@SuppressWarnings("serial") // Same-version serialization only
publicstaticclassForegroundActionextendsStyledTextAction {

/**
 * Creates a new ForegroundAction.
 *
 * @param nm the action name
 * @param fg the foreground color
 */
publicForegroundAction(Stringnm, Colorfg) {
super(nm);
this.fg = fg;
 }

/**
 * Sets the foreground color.
 *
 * @param e the action event
 */
publicvoidactionPerformed(ActionEvente) {
JEditorPaneeditor = getEditor(e);
if (editor != null) {
Colorfg = this.fg;
if ((e != null) && (e.getSource() == editor)) {
Strings = e.getActionCommand();
try {
fg = Color.decode(s);
 } catch (NumberFormatExceptionnfe) {
 }
 }
if (fg != null) {
MutableAttributeSetattr = newSimpleAttributeSet();
StyleConstants.setForeground(attr, fg);
setCharacterAttributes(editor, attr, false);
 } else {
UIManager.getLookAndFeel().provideErrorFeedback(editor);
 }
 }
 }

privateColorfg;
 }

/**
 * An action to set paragraph alignment. This sets the
 * <code>StyleConstants.Alignment</code> attribute for the
 * currently selected range of the target JEditorPane.
 * This is done by calling
 * <code>StyledDocument.setParagraphAttributes</code>
 * on the styled document associated with the target
 * JEditorPane.
 * <p>
 * If the target text component is specified as the
 * source of the ActionEvent and there is a command string,
 * the command string will be interpreted as an integer
 * that should be one of the legal values for the
 * <code>StyleConstants.Alignment</code> attribute.
 * <p>
 * <strong>Warning:</strong>
 * Serialized objects of this class will not be compatible with
 * future Swing releases. The current serialization support is
 * appropriate for short term storage or RMI between applications running
 * the same version of Swing. As of 1.4, support for long term storage
 * of all JavaBeans
 * has been added to the <code>java.beans</code> package.
 * Please see {@link java.beans.XMLEncoder}.
 */
@SuppressWarnings("serial") // Same-version serialization only
publicstaticclassAlignmentActionextendsStyledTextAction {

/**
 * Creates a new AlignmentAction.
 *
 * @param nm the action name
 * @param a the alignment &gt;= 0
 */
publicAlignmentAction(Stringnm, inta) {
super(nm);
this.a = a;
 }

/**
 * Sets the alignment.
 *
 * @param e the action event
 */
publicvoidactionPerformed(ActionEvente) {
JEditorPaneeditor = getEditor(e);
if (editor != null) {
inta = this.a;
if ((e != null) && (e.getSource() == editor)) {
Strings = e.getActionCommand();
try {
a = Integer.parseInt(s, 10);
 } catch (NumberFormatExceptionnfe) {
 }
 }
MutableAttributeSetattr = newSimpleAttributeSet();
StyleConstants.setAlignment(attr, a);
setParagraphAttributes(editor, attr, false);
 }
 }

privateinta;
 }

/**
 * An action to toggle the bold attribute.
 * <p>
 * <strong>Warning:</strong>
 * Serialized objects of this class will not be compatible with
 * future Swing releases. The current serialization support is
 * appropriate for short term storage or RMI between applications running
 * the same version of Swing. As of 1.4, support for long term storage
 * of all JavaBeans
 * has been added to the <code>java.beans</code> package.
 * Please see {@link java.beans.XMLEncoder}.
 */
@SuppressWarnings("serial") // Same-version serialization only
publicstaticclassBoldActionextendsStyledTextAction {

/**
 * Constructs a new BoldAction.
 */
publicBoldAction() {
super("font-bold");
 }

/**
 * Toggles the bold attribute.
 *
 * @param e the action event
 */
publicvoidactionPerformed(ActionEvente) {
JEditorPaneeditor = getEditor(e);
if (editor != null) {
StyledEditorKitkit = getStyledEditorKit(editor);
MutableAttributeSetattr = kit.getInputAttributes();
booleanbold = (StyleConstants.isBold(attr)) ? false : true;
SimpleAttributeSetsas = newSimpleAttributeSet();
StyleConstants.setBold(sas, bold);
setCharacterAttributes(editor, sas, false);
 }
 }
 }

/**
 * An action to toggle the italic attribute.
 * <p>
 * <strong>Warning:</strong>
 * Serialized objects of this class will not be compatible with
 * future Swing releases. The current serialization support is
 * appropriate for short term storage or RMI between applications running
 * the same version of Swing. As of 1.4, support for long term storage
 * of all JavaBeans
 * has been added to the <code>java.beans</code> package.
 * Please see {@link java.beans.XMLEncoder}.
 */
@SuppressWarnings("serial") // Same-version serialization only
publicstaticclassItalicActionextendsStyledTextAction {

/**
 * Constructs a new ItalicAction.
 */
publicItalicAction() {
super("font-italic");
 }

/**
 * Toggles the italic attribute.
 *
 * @param e the action event
 */
publicvoidactionPerformed(ActionEvente) {
JEditorPaneeditor = getEditor(e);
if (editor != null) {
StyledEditorKitkit = getStyledEditorKit(editor);
MutableAttributeSetattr = kit.getInputAttributes();
booleanitalic = (StyleConstants.isItalic(attr)) ? false : true;
SimpleAttributeSetsas = newSimpleAttributeSet();
StyleConstants.setItalic(sas, italic);
setCharacterAttributes(editor, sas, false);
 }
 }
 }

/**
 * An action to toggle the underline attribute.
 * <p>
 * <strong>Warning:</strong>
 * Serialized objects of this class will not be compatible with
 * future Swing releases. The current serialization support is
 * appropriate for short term storage or RMI between applications running
 * the same version of Swing. As of 1.4, support for long term storage
 * of all JavaBeans
 * has been added to the <code>java.beans</code> package.
 * Please see {@link java.beans.XMLEncoder}.
 */
@SuppressWarnings("serial") // Same-version serialization only
publicstaticclassUnderlineActionextendsStyledTextAction {

/**
 * Constructs a new UnderlineAction.
 */
publicUnderlineAction() {
super("font-underline");
 }

/**
 * Toggles the Underline attribute.
 *
 * @param e the action event
 */
publicvoidactionPerformed(ActionEvente) {
JEditorPaneeditor = getEditor(e);
if (editor != null) {
StyledEditorKitkit = getStyledEditorKit(editor);
MutableAttributeSetattr = kit.getInputAttributes();
booleanunderline = (StyleConstants.isUnderline(attr)) ? false : true;
SimpleAttributeSetsas = newSimpleAttributeSet();
StyleConstants.setUnderline(sas, underline);
setCharacterAttributes(editor, sas, false);
 }
 }
 }


/**
 * StyledInsertBreakAction has similar behavior to that of
 * <code>DefaultEditorKit.InsertBreakAction</code>. That is when
 * its <code>actionPerformed</code> method is invoked, a newline
 * is inserted. Beyond that, this will reset the input attributes to
 * what they were before the newline was inserted.
 */
@SuppressWarnings("serial") // Superclass is not serializable across versions
staticclassStyledInsertBreakActionextendsStyledTextAction {
privateSimpleAttributeSettempSet;

StyledInsertBreakAction() {
super(insertBreakAction);
 }

publicvoidactionPerformed(ActionEvente) {
JEditorPanetarget = getEditor(e);

if (target != null) {
if ((!target.isEditable()) || (!target.isEnabled())) {
UIManager.getLookAndFeel().provideErrorFeedback(target);
return;
 }
StyledEditorKitsek = getStyledEditorKit(target);

if (tempSet != null) {
tempSet.removeAttributes(tempSet);
 }
else {
tempSet = newSimpleAttributeSet();
 }
tempSet.addAttributes(sek.getInputAttributes());
target.replaceSelection("\n");

MutableAttributeSetia = sek.getInputAttributes();

ia.removeAttributes(ia);
ia.addAttributes(tempSet);
tempSet.removeAttributes(tempSet);
 }
else {
// See if we are in a JTextComponent.
JTextComponenttext = getTextComponent(e);

if (text != null) {
if ((!text.isEditable()) || (!text.isEnabled())) {
UIManager.getLookAndFeel().provideErrorFeedback(target);
return;
 }
text.replaceSelection("\n");
 }
 }
 }
 }
}