home *** CD-ROM | disk | FTP | other *** search
/ Java 1.2 How-To / JavaHowTo.iso / 3rdParty / jbuilder / unsupported / JDK1.2beta3 / SOURCE / SRC.ZIP / java / awt / swing / JTextPane.java < prev    next >
Encoding:
Java Source  |  1998-03-20  |  13.4 KB  |  405 lines
  1. /*
  2.  * @(#)JTextPane.java    1.54 98/02/05
  3.  * 
  4.  * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  * 
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  * 
  19.  */
  20. package java.awt.swing;
  21.  
  22. import java.awt.*;
  23. import java.awt.event.ActionEvent;
  24. import java.io.Serializable;
  25. import java.awt.swing.text.*;
  26. import java.awt.swing.event.*;
  27. import java.awt.swing.plaf.*;
  28.  
  29. /**
  30.  * A text component that can be marked up with attributes that are
  31.  * represented graphically.  This component models paragraphs
  32.  * that are composed of runs of character level attributes.  Each
  33.  * paragraph may have a logical style attached to it which contains
  34.  * the default attributes to use if no overriden by attributes set
  35.  * on the paragraph or character run.  Components and images may
  36.  * be embedded in the flow of text.
  37.  * <p>
  38.  * Warning: serialized objects of this class will not be compatible with
  39.  * future swing releases.  The current serialization support is appropriate
  40.  * for short term storage or RMI between Swing1.0 applications.  It will
  41.  * not be possible to load serialized Swing1.0 objects with future releases
  42.  * of Swing.  The JDK1.2 release of Swing will be the compatibility
  43.  * baseline for the serialized form of Swing objects.
  44.  *
  45.  * @author  Timothy Prinzing
  46.  * @version 1.54 02/05/98
  47.  * @see StyledEditorKit
  48.  */
  49. public class JTextPane extends JEditorPane {
  50.  
  51.     /**
  52.      * Constructs a new JTextPane.
  53.      */
  54.     public JTextPane() {
  55.     super();
  56.     setEditorKit(new StyledEditorKit());
  57.     }
  58.  
  59.     /**
  60.      * Constructs a new JTextPane, with a specified document model and
  61.      * style context.
  62.      *
  63.      * @param doc the document model
  64.      */
  65.     public JTextPane(StyledDocument doc) {
  66.     this();
  67.     setStyledDocument(doc);
  68.     }
  69.  
  70.     /**
  71.      * Returns the class ID for the UI.
  72.      *
  73.      * @return the ID
  74.      * @see JComponent#getUIClassID
  75.      * @see UIDefaults#getUI
  76.      */
  77.     public String getUIClassID() {
  78.     return "TextPaneUI";
  79.     }
  80.  
  81.     /**
  82.      * Associates the editor with a text document.  This
  83.      * must be a StyledDocument.
  84.      *
  85.      * @param doc  the document to display/edit
  86.      * @exception IllegalArgumentException  if doc can't
  87.      * be narrowed to a StyledDocument which is the
  88.      * required type of model for this text component
  89.      */
  90.     public void setDocument(Document doc) {
  91.     if (doc instanceof StyledDocument) {
  92.         super.setDocument(doc);
  93.     } else {
  94.         throw new IllegalArgumentException("Model must be StyledDocument");
  95.     }
  96.     }
  97.  
  98.     /**
  99.      * Associates the editor with a text document.
  100.      * The currently registered factory is used to build a view for
  101.      * the document, which gets displayed by the editor.
  102.      *
  103.      * @param doc  the document to display/edit
  104.      */
  105.     public void setStyledDocument(StyledDocument doc) {
  106.     super.setDocument(doc);
  107.     }
  108.  
  109.     /**
  110.      * Fetches the model associated with the editor.  
  111.      *
  112.      * @return the model
  113.      */
  114.     public StyledDocument getStyledDocument() {
  115.     return (StyledDocument) getDocument();
  116.     }
  117.  
  118.     /**
  119.      * Replaces the currently selected content with new content
  120.      * represented by the given string.  If there is no selection
  121.      * this amounts to an insert of the given text.  If there
  122.      * is no replacement text this amounts to a removal of the
  123.      * current selection.  The replacement text will have the
  124.      * attributes currently defined for input.
  125.      * <p>
  126.      * This method is thread safe, although most Swing methods
  127.      * are not. Please see 
  128.      * <A HREF="http://java.sun.com/products/jfc/swingdoc/threads.html">Threads
  129.      * and Swing</A> for more information.     
  130.      *
  131.      * @param content  the content to replace the selection with
  132.      */
  133.     public void replaceSelection(String content) {
  134.     if (! isEditable()) {
  135.         getToolkit().beep();
  136.         return;
  137.     }
  138.     Document doc = getStyledDocument();
  139.     if (doc != null) {
  140.         try {
  141.         Caret caret = getCaret();
  142.         int p0 = Math.min(caret.getDot(), caret.getMark());
  143.         int p1 = Math.max(caret.getDot(), caret.getMark());
  144.         if (p0 != p1) {
  145.             doc.remove(p0, p1 - p0);
  146.         }
  147.         if (content != null && content.length() > 0) {
  148.             doc.insertString(p0, content, getInputAttributes());
  149.         }
  150.         } catch (BadLocationException e) {
  151.         getToolkit().beep();
  152.         }
  153.     }
  154.     }
  155.  
  156.     /**
  157.      * Inserts a component into the document as a replacement
  158.      * for the currently selected content.  If there is no
  159.      * selection the component is effectively inserted at the 
  160.      * current position of the caret.  This is represented in
  161.      * the associated document as an attribute of one character 
  162.      * of content.  
  163.      *
  164.      * @param c    the component to insert
  165.      */
  166.     public void insertComponent(Component c) {
  167.     MutableAttributeSet inputAttributes = getInputAttributes();
  168.     inputAttributes.removeAttributes(inputAttributes);
  169.     StyleConstants.setComponent(inputAttributes, c);
  170.     replaceSelection(" ");
  171.     inputAttributes.removeAttributes(inputAttributes);
  172.     }
  173.  
  174.     /**
  175.      * Inserts an icon into the document as a replacement
  176.      * for the currently selected content.  If there is no
  177.      * selection the icon is effectively inserted at the 
  178.      * current position of the caret.  This is represented in
  179.      * the associated document as an attribute of one character 
  180.      * of content.  
  181.      * <p>
  182.      * This method is thread safe, although most Swing methods
  183.      * are not. Please see 
  184.      * <A HREF="http://java.sun.com/products/jfc/swingdoc/threads.html">Threads
  185.      * and Swing</A> for more information.     
  186.      *
  187.      * @param g    the icon to insert
  188.      * @see Icon
  189.      */
  190.     public void insertIcon(Icon g) {
  191.     MutableAttributeSet inputAttributes = getInputAttributes();
  192.     inputAttributes.removeAttributes(inputAttributes);
  193.     StyleConstants.setIcon(inputAttributes, g);
  194.     replaceSelection(" ");
  195.     inputAttributes.removeAttributes(inputAttributes);
  196.     }
  197.  
  198.     /**
  199.      * Adds a new style into the logical style hierarchy.  Style attributes
  200.      * resolve from bottom up so an attribute specified in a child
  201.      * will override an attribute specified in the parent.
  202.      *
  203.      * @param nm   the name of the style (must be unique within the
  204.      *   collection of named styles).  The name may be null if the style 
  205.      *   is unnamed, but the caller is responsible
  206.      *   for managing the reference returned as an unnamed style can't
  207.      *   be fetched by name.  An unnamed style may be useful for things
  208.      *   like character attribute overrides such as found in a style 
  209.      *   run.
  210.      * @param parent the parent style.  This may be null if unspecified
  211.      *   attributes need not be resolved in some other style.
  212.      * @return the new Style 
  213.      */
  214.     public Style addStyle(String nm, Style parent) {
  215.     StyledDocument doc = getStyledDocument();
  216.     return doc.addStyle(nm, parent);
  217.     }
  218.  
  219.     /**
  220.      * Removes a named style previously added to the document.  
  221.      *
  222.      * @param nm  the name of the style to remove
  223.      */
  224.     public void removeStyle(String nm) {
  225.     StyledDocument doc = getStyledDocument();
  226.     doc.removeStyle(nm);
  227.     }
  228.  
  229.     /**
  230.      * Fetches a named style previously added.
  231.      *
  232.      * @param nm  the name of the style
  233.      * @return the style
  234.      */
  235.     public Style getStyle(String nm) {
  236.     StyledDocument doc = getStyledDocument();
  237.     return doc.getStyle(nm);
  238.     }
  239.  
  240.     /**
  241.      * Sets the logical style to use for the paragraph at the
  242.      * current caret position.  If attributes aren't explicity set 
  243.      * for character and paragraph attributes they will resolve 
  244.      * through the logical style assigned to the paragraph, which
  245.      * in term may resolve through some hierarchy completely 
  246.      * independant of the element hierarchy in the document.
  247.      * <p>
  248.      * This method is thread safe, although most Swing methods
  249.      * are not. Please see 
  250.      * <A HREF="http://java.sun.com/products/jfc/swingdoc/threads.html">Threads
  251.      * and Swing</A> for more information.     
  252.      *
  253.      * @param s  the logical style to assign to the paragraph
  254.      */
  255.     public void setLogicalStyle(Style s) {
  256.     StyledDocument doc = getStyledDocument();
  257.     doc.setLogicalStyle(getCaretPosition(), s);
  258.     }
  259.  
  260.     /** 
  261.      * Fetches the logical style assigned to the paragraph 
  262.      * represented by the current position of the caret.
  263.      *
  264.      * @return the style
  265.      */
  266.     public Style getLogicalStyle() {
  267.     StyledDocument doc = getStyledDocument();
  268.     return doc.getLogicalStyle(getCaretPosition());
  269.     }
  270.  
  271.     /**
  272.      * Fetches the character attributes in effect at the 
  273.      * current location of the caret.  
  274.      *
  275.      * @return the attributes
  276.      */
  277.     public AttributeSet getCharacterAttributes() {
  278.     StyledDocument doc = getStyledDocument();
  279.     Element run = doc.getCharacterElement(getCaretPosition());
  280.     if (run != null) {
  281.         return run.getAttributes();
  282.     }
  283.     return null;
  284.     }
  285.  
  286.     /**
  287.      * Applies the given attributes to character 
  288.      * content.  If there is a selection, the attributes
  289.      * are applied to the selection range.  If there
  290.      * is no selection, the attributes are applied to
  291.      * the input attribute set which defines the attributes
  292.      * for any new text that gets inserted.
  293.      * <p>
  294.      * This method is thread safe, although most Swing methods
  295.      * are not. Please see 
  296.      * <A HREF="http://java.sun.com/products/jfc/swingdoc/threads.html">Threads
  297.      * and Swing</A> for more information.     
  298.      *
  299.      * @param attr the attributes
  300.      * @param replace if true, then replace the existing attributes first
  301.      */
  302.     public void setCharacterAttributes(AttributeSet attr, boolean replace) {
  303.     int p0 = getSelectionStart();
  304.     int p1 = getSelectionEnd();
  305.     if (p0 != p1) {
  306.         StyledDocument doc = getStyledDocument();
  307.         doc.setCharacterAttributes(p0, p1 - p0, attr, replace);
  308.     } else {
  309.         MutableAttributeSet inputAttributes = getInputAttributes();
  310.         if (replace) {
  311.         inputAttributes.removeAttributes(inputAttributes);
  312.         }
  313.         inputAttributes.addAttributes(attr);
  314.     }
  315.     }
  316.  
  317.     /**
  318.      * Fetches the current paragraph attributes in effect
  319.      * at the location of the caret.
  320.      *
  321.      * @return the attributes
  322.      */
  323.     public AttributeSet getParagraphAttributes() {
  324.     StyledDocument doc = getStyledDocument();
  325.     Element paragraph = doc.getParagraphElement(getCaretPosition());
  326.     if (paragraph != null) {
  327.         return paragraph.getAttributes();
  328.     }
  329.     return null;
  330.     }
  331.  
  332.     /**
  333.      * Applies the given attributes to paragraphs.  If
  334.      * there is a selection, the attributes are applied
  335.      * to the paragraphs that intersect the selection.
  336.      * if there is no selection, the attributes are applied
  337.      * to the paragraph at the current caret position.
  338.      * <p>
  339.      * This method is thread safe, although most Swing methods
  340.      * are not. Please see 
  341.      * <A HREF="http://java.sun.com/products/jfc/swingdoc/threads.html">Threads
  342.      * and Swing</A> for more information.     
  343.      *
  344.      * @param attr the attributes
  345.      * @param replace if true, replace the existing attributes first
  346.      */
  347.     public void setParagraphAttributes(AttributeSet attr, boolean replace) {
  348.     int p0 = getSelectionStart();
  349.     int p1 = getSelectionEnd();
  350.     StyledDocument doc = getStyledDocument();
  351.     doc.setParagraphAttributes(p0, p1 - p0, attr, replace);
  352.     }
  353.  
  354.     /**
  355.      * Gets the input attributes for the pane.
  356.      *
  357.      * @return the attributes
  358.      */
  359.     public MutableAttributeSet getInputAttributes() {
  360.     return getStyledEditorKit().getInputAttributes();
  361.     }
  362.  
  363.     protected final StyledEditorKit getStyledEditorKit() {
  364.     return (StyledEditorKit) getEditorKit();
  365.     }
  366.  
  367.     // --- JEditorPane ------------------------------------
  368.  
  369.     /**
  370.      * Creates the EditorKit to use by default.  This
  371.      * is implemented to return StyledEditorKit.
  372.      */
  373.     protected EditorKit createDefaultEditorKit() {
  374.     return new StyledEditorKit();
  375.     }
  376.  
  377.     /**
  378.      * Sets the currently installed kit for handling
  379.      * content.  This is the bound property that
  380.      * establishes the content type of the editor.
  381.      * 
  382.      * @param kit the desired editor behavior.
  383.      */
  384.     public final void setEditorKit(EditorKit kit) {
  385.     if (kit instanceof StyledEditorKit) {
  386.         super.setEditorKit(kit);
  387.     } else {
  388.         throw new IllegalArgumentException("Must be StyledEditorKit");
  389.     }
  390.     }
  391.  
  392.     // --- Scrollable  ----------------------------------------
  393.  
  394.     /**
  395.      * Returns true if a viewport should always force the width of this 
  396.      * Scrollable to match the width of the viewport.  
  397.      * 
  398.      * @return True if a viewport should force the Scrollables width to match its own.
  399.      */
  400.     public boolean getScrollableTracksViewportWidth() {
  401.     return true;
  402.     }
  403.  
  404. }
  405.