You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
896 lines
31 KiB
896 lines
31 KiB
/*
|
|
* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
|
|
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
package javax.swing.text;
|
|
|
|
import java.io.*;
|
|
import java.awt.*;
|
|
import java.awt.event.ActionEvent;
|
|
import java.beans.PropertyChangeEvent;
|
|
import java.beans.PropertyChangeListener;
|
|
import javax.swing.event.*;
|
|
import javax.swing.Action;
|
|
import javax.swing.JEditorPane;
|
|
import javax.swing.KeyStroke;
|
|
import javax.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
|
|
*/
|
|
public class StyledEditorKit extends DefaultEditorKit {
|
|
|
|
/**
|
|
* Creates a new EditorKit used for styled documents.
|
|
*/
|
|
public StyledEditorKit() {
|
|
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
|
|
*/
|
|
public MutableAttributeSet getInputAttributes() {
|
|
return inputAttributes;
|
|
}
|
|
|
|
/**
|
|
* Fetches the element representing the current
|
|
* run of character attributes for the caret.
|
|
*
|
|
* @return the element
|
|
*/
|
|
public Element getCharacterAttributeRun() {
|
|
return currentRun;
|
|
}
|
|
|
|
// --- 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
|
|
*/
|
|
public Action[] getActions() {
|
|
return TextAction.augmentList(super.getActions(), this.defaultActions);
|
|
}
|
|
|
|
/**
|
|
* Creates an uninitialized text storage model
|
|
* that is appropriate for this type of editor.
|
|
*
|
|
* @return the model
|
|
*/
|
|
public Document createDefaultDocument() {
|
|
return new DefaultStyledDocument();
|
|
}
|
|
|
|
/**
|
|
* Called when the kit is being installed into
|
|
* a JEditorPane.
|
|
*
|
|
* @param c the JEditorPane
|
|
*/
|
|
public void install(JEditorPane c) {
|
|
c.addCaretListener(inputAttributeUpdater);
|
|
c.addPropertyChangeListener(inputAttributeUpdater);
|
|
Caret caret = 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
|
|
*/
|
|
public void deinstall(JEditorPane c) {
|
|
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
|
|
*/
|
|
public ViewFactory getViewFactory() {
|
|
return defaultFactory;
|
|
}
|
|
|
|
/**
|
|
* Creates a copy of the editor kit.
|
|
*
|
|
* @return the copy
|
|
*/
|
|
public Object clone() {
|
|
StyledEditorKit o = (StyledEditorKit)super.clone();
|
|
o.currentRun = o.currentParagraph = null;
|
|
o.createInputAttributeUpdated();
|
|
o.createInputAttributes();
|
|
return o;
|
|
}
|
|
|
|
/**
|
|
* Creates the AttributeSet used for the selection.
|
|
*/
|
|
private void createInputAttributes() {
|
|
inputAttributes = new SimpleAttributeSet() {
|
|
public AttributeSet getResolveParent() {
|
|
return (currentParagraph != null) ?
|
|
currentParagraph.getAttributes() : null;
|
|
}
|
|
|
|
public Object clone() {
|
|
return new SimpleAttributeSet(this);
|
|
}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Creates a new <code>AttributeTracker</code>.
|
|
*/
|
|
private void createInputAttributeUpdated() {
|
|
inputAttributeUpdater = new AttributeTracker();
|
|
}
|
|
|
|
|
|
private static final ViewFactory defaultFactory = new StyledViewFactory();
|
|
|
|
Element currentRun;
|
|
Element currentParagraph;
|
|
|
|
/**
|
|
* This is the set of attributes used to store the
|
|
* input attributes.
|
|
*/
|
|
MutableAttributeSet inputAttributes;
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
private AttributeTracker inputAttributeUpdater;
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
class AttributeTracker implements CaretListener, PropertyChangeListener, Serializable {
|
|
|
|
/**
|
|
* Updates the attributes. <code>dot</code> and <code>mark</code>
|
|
* mark give the positions of the selection in <code>c</code>.
|
|
*/
|
|
void updateInputAttributes(int dot, int mark, JTextComponent c) {
|
|
// EditorKit might not have installed the StyledDocument yet.
|
|
Document aDoc = c.getDocument();
|
|
if (!(aDoc instanceof StyledDocument)) {
|
|
return ;
|
|
}
|
|
int start = Math.min(dot, mark);
|
|
// record current character attributes.
|
|
StyledDocument doc = (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.
|
|
Element run;
|
|
currentParagraph = doc.getParagraphElement(start);
|
|
if (currentParagraph.getStartOffset() == start || dot != mark) {
|
|
// Get the attributes from the character at the selection
|
|
// if in a different paragrah!
|
|
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());
|
|
}
|
|
}
|
|
|
|
public void propertyChange(PropertyChangeEvent evt) {
|
|
Object newValue = evt.getNewValue();
|
|
Object source = evt.getSource();
|
|
|
|
if ((source instanceof JTextComponent) &&
|
|
(newValue instanceof Document)) {
|
|
// New document will have changed selection to 0,0.
|
|
updateInputAttributes(0, 0, (JTextComponent)source);
|
|
}
|
|
}
|
|
|
|
public void caretUpdate(CaretEvent e) {
|
|
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.
|
|
*
|
|
*/
|
|
protected void createInputAttributes(Element element,
|
|
MutableAttributeSet set) {
|
|
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 ---------------------
|
|
|
|
static class StyledViewFactory implements ViewFactory {
|
|
|
|
public View create(Element elem) {
|
|
String kind = elem.getName();
|
|
if (kind != null) {
|
|
if (kind.equals(AbstractDocument.ContentElementName)) {
|
|
return new LabelView(elem);
|
|
} else if (kind.equals(AbstractDocument.ParagraphElementName)) {
|
|
return new ParagraphView(elem);
|
|
} else if (kind.equals(AbstractDocument.SectionElementName)) {
|
|
return new BoxView(elem, View.Y_AXIS);
|
|
} else if (kind.equals(StyleConstants.ComponentElementName)) {
|
|
return new ComponentView(elem);
|
|
} else if (kind.equals(StyleConstants.IconElementName)) {
|
|
return new IconView(elem);
|
|
}
|
|
}
|
|
|
|
// default to text display
|
|
return new LabelView(elem);
|
|
}
|
|
|
|
}
|
|
|
|
// --- Action implementations ---------------------------------
|
|
|
|
private static final Action[] defaultActions = {
|
|
new FontFamilyAction("font-family-SansSerif", "SansSerif"),
|
|
new FontFamilyAction("font-family-Monospaced", "Monospaced"),
|
|
new FontFamilyAction("font-family-Serif", "Serif"),
|
|
new FontSizeAction("font-size-8", 8),
|
|
new FontSizeAction("font-size-10", 10),
|
|
new FontSizeAction("font-size-12", 12),
|
|
new FontSizeAction("font-size-14", 14),
|
|
new FontSizeAction("font-size-16", 16),
|
|
new FontSizeAction("font-size-18", 18),
|
|
new FontSizeAction("font-size-24", 24),
|
|
new FontSizeAction("font-size-36", 36),
|
|
new FontSizeAction("font-size-48", 48),
|
|
new AlignmentAction("left-justify", StyleConstants.ALIGN_LEFT),
|
|
new AlignmentAction("center-justify", StyleConstants.ALIGN_CENTER),
|
|
new AlignmentAction("right-justify", StyleConstants.ALIGN_RIGHT),
|
|
new BoldAction(),
|
|
new ItalicAction(),
|
|
new StyledInsertBreakAction(),
|
|
new UnderlineAction()
|
|
};
|
|
|
|
/**
|
|
* 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}.
|
|
*/
|
|
public abstract static class StyledTextAction extends TextAction {
|
|
|
|
/**
|
|
* Creates a new StyledTextAction from a string action name.
|
|
*
|
|
* @param nm the name of the action
|
|
*/
|
|
public StyledTextAction(String nm) {
|
|
super(nm);
|
|
}
|
|
|
|
/**
|
|
* Gets the target editor for an action.
|
|
*
|
|
* @param e the action event
|
|
* @return the editor
|
|
*/
|
|
protected final JEditorPane getEditor(ActionEvent e) {
|
|
JTextComponent tcomp = getTextComponent(e);
|
|
if (tcomp instanceof JEditorPane) {
|
|
return (JEditorPane) tcomp;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Gets the document associated with an editor pane.
|
|
*
|
|
* @param e the editor
|
|
* @return the document
|
|
* @exception IllegalArgumentException for the wrong document type
|
|
*/
|
|
protected final StyledDocument getStyledDocument(JEditorPane e) {
|
|
Document d = e.getDocument();
|
|
if (d instanceof StyledDocument) {
|
|
return (StyledDocument) d;
|
|
}
|
|
throw new IllegalArgumentException("document must be StyledDocument");
|
|
}
|
|
|
|
/**
|
|
* Gets the editor kit associated with an editor pane.
|
|
*
|
|
* @param e the editor pane
|
|
* @return the kit
|
|
* @exception IllegalArgumentException for the wrong document type
|
|
*/
|
|
protected final StyledEditorKit getStyledEditorKit(JEditorPane e) {
|
|
EditorKit k = e.getEditorKit();
|
|
if (k instanceof StyledEditorKit) {
|
|
return (StyledEditorKit) k;
|
|
}
|
|
throw new IllegalArgumentException("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
|
|
*/
|
|
protected final void setCharacterAttributes(JEditorPane editor,
|
|
AttributeSet attr, boolean replace) {
|
|
int p0 = editor.getSelectionStart();
|
|
int p1 = editor.getSelectionEnd();
|
|
if (p0 != p1) {
|
|
StyledDocument doc = getStyledDocument(editor);
|
|
doc.setCharacterAttributes(p0, p1 - p0, attr, replace);
|
|
}
|
|
StyledEditorKit k = getStyledEditorKit(editor);
|
|
MutableAttributeSet inputAttributes = 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
|
|
*/
|
|
protected final void setParagraphAttributes(JEditorPane editor,
|
|
AttributeSet attr, boolean replace) {
|
|
int p0 = editor.getSelectionStart();
|
|
int p1 = editor.getSelectionEnd();
|
|
StyledDocument doc = 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}.
|
|
*/
|
|
public static class FontFamilyAction extends StyledTextAction {
|
|
|
|
/**
|
|
* Creates a new FontFamilyAction.
|
|
*
|
|
* @param nm the action name
|
|
* @param family the font family
|
|
*/
|
|
public FontFamilyAction(String nm, String family) {
|
|
super(nm);
|
|
this.family = family;
|
|
}
|
|
|
|
/**
|
|
* Sets the font family.
|
|
*
|
|
* @param e the event
|
|
*/
|
|
public void actionPerformed(ActionEvent e) {
|
|
JEditorPane editor = getEditor(e);
|
|
if (editor != null) {
|
|
String family = this.family;
|
|
if ((e != null) && (e.getSource() == editor)) {
|
|
String s = e.getActionCommand();
|
|
if (s != null) {
|
|
family = s;
|
|
}
|
|
}
|
|
if (family != null) {
|
|
MutableAttributeSet attr = new SimpleAttributeSet();
|
|
StyleConstants.setFontFamily(attr, family);
|
|
setCharacterAttributes(editor, attr, false);
|
|
} else {
|
|
UIManager.getLookAndFeel().provideErrorFeedback(editor);
|
|
}
|
|
}
|
|
}
|
|
|
|
private String family;
|
|
}
|
|
|
|
/**
|
|
* 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}.
|
|
*/
|
|
public static class FontSizeAction extends StyledTextAction {
|
|
|
|
/**
|
|
* Creates a new FontSizeAction.
|
|
*
|
|
* @param nm the action name
|
|
* @param size the font size
|
|
*/
|
|
public FontSizeAction(String nm, int size) {
|
|
super(nm);
|
|
this.size = size;
|
|
}
|
|
|
|
/**
|
|
* Sets the font size.
|
|
*
|
|
* @param e the action event
|
|
*/
|
|
public void actionPerformed(ActionEvent e) {
|
|
JEditorPane editor = getEditor(e);
|
|
if (editor != null) {
|
|
int size = this.size;
|
|
if ((e != null) && (e.getSource() == editor)) {
|
|
String s = e.getActionCommand();
|
|
try {
|
|
size = Integer.parseInt(s, 10);
|
|
} catch (NumberFormatException nfe) {
|
|
}
|
|
}
|
|
if (size != 0) {
|
|
MutableAttributeSet attr = new SimpleAttributeSet();
|
|
StyleConstants.setFontSize(attr, size);
|
|
setCharacterAttributes(editor, attr, false);
|
|
} else {
|
|
UIManager.getLookAndFeel().provideErrorFeedback(editor);
|
|
}
|
|
}
|
|
}
|
|
|
|
private int size;
|
|
}
|
|
|
|
/**
|
|
* 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}.
|
|
*/
|
|
public static class ForegroundAction extends StyledTextAction {
|
|
|
|
/**
|
|
* Creates a new ForegroundAction.
|
|
*
|
|
* @param nm the action name
|
|
* @param fg the foreground color
|
|
*/
|
|
public ForegroundAction(String nm, Color fg) {
|
|
super(nm);
|
|
this.fg = fg;
|
|
}
|
|
|
|
/**
|
|
* Sets the foreground color.
|
|
*
|
|
* @param e the action event
|
|
*/
|
|
public void actionPerformed(ActionEvent e) {
|
|
JEditorPane editor = getEditor(e);
|
|
if (editor != null) {
|
|
Color fg = this.fg;
|
|
if ((e != null) && (e.getSource() == editor)) {
|
|
String s = e.getActionCommand();
|
|
try {
|
|
fg = Color.decode(s);
|
|
} catch (NumberFormatException nfe) {
|
|
}
|
|
}
|
|
if (fg != null) {
|
|
MutableAttributeSet attr = new SimpleAttributeSet();
|
|
StyleConstants.setForeground(attr, fg);
|
|
setCharacterAttributes(editor, attr, false);
|
|
} else {
|
|
UIManager.getLookAndFeel().provideErrorFeedback(editor);
|
|
}
|
|
}
|
|
}
|
|
|
|
private Color fg;
|
|
}
|
|
|
|
/**
|
|
* 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}.
|
|
*/
|
|
public static class AlignmentAction extends StyledTextAction {
|
|
|
|
/**
|
|
* Creates a new AlignmentAction.
|
|
*
|
|
* @param nm the action name
|
|
* @param a the alignment >= 0
|
|
*/
|
|
public AlignmentAction(String nm, int a) {
|
|
super(nm);
|
|
this.a = a;
|
|
}
|
|
|
|
/**
|
|
* Sets the alignment.
|
|
*
|
|
* @param e the action event
|
|
*/
|
|
public void actionPerformed(ActionEvent e) {
|
|
JEditorPane editor = getEditor(e);
|
|
if (editor != null) {
|
|
int a = this.a;
|
|
if ((e != null) && (e.getSource() == editor)) {
|
|
String s = e.getActionCommand();
|
|
try {
|
|
a = Integer.parseInt(s, 10);
|
|
} catch (NumberFormatException nfe) {
|
|
}
|
|
}
|
|
MutableAttributeSet attr = new SimpleAttributeSet();
|
|
StyleConstants.setAlignment(attr, a);
|
|
setParagraphAttributes(editor, attr, false);
|
|
}
|
|
}
|
|
|
|
private int a;
|
|
}
|
|
|
|
/**
|
|
* 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}.
|
|
*/
|
|
public static class BoldAction extends StyledTextAction {
|
|
|
|
/**
|
|
* Constructs a new BoldAction.
|
|
*/
|
|
public BoldAction() {
|
|
super("font-bold");
|
|
}
|
|
|
|
/**
|
|
* Toggles the bold attribute.
|
|
*
|
|
* @param e the action event
|
|
*/
|
|
public void actionPerformed(ActionEvent e) {
|
|
JEditorPane editor = getEditor(e);
|
|
if (editor != null) {
|
|
StyledEditorKit kit = getStyledEditorKit(editor);
|
|
MutableAttributeSet attr = kit.getInputAttributes();
|
|
boolean bold = (StyleConstants.isBold(attr)) ? false : true;
|
|
SimpleAttributeSet sas = new SimpleAttributeSet();
|
|
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}.
|
|
*/
|
|
public static class ItalicAction extends StyledTextAction {
|
|
|
|
/**
|
|
* Constructs a new ItalicAction.
|
|
*/
|
|
public ItalicAction() {
|
|
super("font-italic");
|
|
}
|
|
|
|
/**
|
|
* Toggles the italic attribute.
|
|
*
|
|
* @param e the action event
|
|
*/
|
|
public void actionPerformed(ActionEvent e) {
|
|
JEditorPane editor = getEditor(e);
|
|
if (editor != null) {
|
|
StyledEditorKit kit = getStyledEditorKit(editor);
|
|
MutableAttributeSet attr = kit.getInputAttributes();
|
|
boolean italic = (StyleConstants.isItalic(attr)) ? false : true;
|
|
SimpleAttributeSet sas = new SimpleAttributeSet();
|
|
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}.
|
|
*/
|
|
public static class UnderlineAction extends StyledTextAction {
|
|
|
|
/**
|
|
* Constructs a new UnderlineAction.
|
|
*/
|
|
public UnderlineAction() {
|
|
super("font-underline");
|
|
}
|
|
|
|
/**
|
|
* Toggles the Underline attribute.
|
|
*
|
|
* @param e the action event
|
|
*/
|
|
public void actionPerformed(ActionEvent e) {
|
|
JEditorPane editor = getEditor(e);
|
|
if (editor != null) {
|
|
StyledEditorKit kit = getStyledEditorKit(editor);
|
|
MutableAttributeSet attr = kit.getInputAttributes();
|
|
boolean underline = (StyleConstants.isUnderline(attr)) ? false : true;
|
|
SimpleAttributeSet sas = new SimpleAttributeSet();
|
|
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.
|
|
*/
|
|
static class StyledInsertBreakAction extends StyledTextAction {
|
|
private SimpleAttributeSet tempSet;
|
|
|
|
StyledInsertBreakAction() {
|
|
super(insertBreakAction);
|
|
}
|
|
|
|
public void actionPerformed(ActionEvent e) {
|
|
JEditorPane target = getEditor(e);
|
|
|
|
if (target != null) {
|
|
if ((!target.isEditable()) || (!target.isEnabled())) {
|
|
UIManager.getLookAndFeel().provideErrorFeedback(target);
|
|
return;
|
|
}
|
|
StyledEditorKit sek = getStyledEditorKit(target);
|
|
|
|
if (tempSet != null) {
|
|
tempSet.removeAttributes(tempSet);
|
|
}
|
|
else {
|
|
tempSet = new SimpleAttributeSet();
|
|
}
|
|
tempSet.addAttributes(sek.getInputAttributes());
|
|
target.replaceSelection("\n");
|
|
|
|
MutableAttributeSet ia = sek.getInputAttributes();
|
|
|
|
ia.removeAttributes(ia);
|
|
ia.addAttributes(tempSet);
|
|
tempSet.removeAttributes(tempSet);
|
|
}
|
|
else {
|
|
// See if we are in a JTextComponent.
|
|
JTextComponent text = getTextComponent(e);
|
|
|
|
if (text != null) {
|
|
if ((!text.isEditable()) || (!text.isEnabled())) {
|
|
UIManager.getLookAndFeel().provideErrorFeedback(target);
|
|
return;
|
|
}
|
|
text.replaceSelection("\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|