1 /*

     2  * Copyright 1997-2007 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Sun designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Sun in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    22  * CA 95054 USA or visit www.sun.com if you need additional information or

    23  * have any questions.

    24  */

    25 package javax.swing.text;

    26 

    27 import java.io.*;

    28 import java.awt.*;

    29 import java.awt.event.ActionEvent;

    30 import java.text.*;

    31 import javax.swing.Action;

    32 import javax.swing.KeyStroke;

    33 import javax.swing.SwingConstants;

    34 import javax.swing.UIManager;

    35 

    36 /**

    37  * This is the set of things needed by a text component

    38  * to be a reasonably functioning editor for some <em>type</em>

    39  * of text document.  This implementation provides a default

    40  * implementation which treats text as plain text and

    41  * provides a minimal set of actions for a simple editor.

    42  * <p>

    43  * <dl>

    44  * <dt><b><font size=+1>Newlines</font></b>

    45  * <dd>

    46  * There are two properties which deal with newlines.  The

    47  * system property, <code>line.separator</code>, is defined to be

    48  * platform-dependent, either "\n", "\r", or "\r\n".  There is also

    49  * a property defined in <code>DefaultEditorKit</code>, called

    50  * <a href=#EndOfLineStringProperty><code>EndOfLineStringProperty</code></a>,

    51  * which is defined automatically when a document is loaded, to be

    52  * the first occurrence of any of the newline characters.

    53  * When a document is loaded, <code>EndOfLineStringProperty</code>

    54  * is set appropriately, and when the document is written back out, the

    55  * <code>EndOfLineStringProperty</code> is used.  But while the document

    56  * is in memory, the "\n" character is used to define a

    57  * newline, regardless of how the newline is defined when

    58  * the document is on disk.  Therefore, for searching purposes,

    59  * "\n" should always be used.  When a new document is created,

    60  * and the <code>EndOfLineStringProperty</code> has not been defined,

    61  * it will use the System property when writing out the

    62  * document.

    63  * <p>Note that <code>EndOfLineStringProperty</code> is set

    64  * on the <code>Document</code> using the <code>get/putProperty</code>

    65  * methods.  Subclasses may override this behavior.

    66  *

    67  * </dl>

    68  *

    69  * @author  Timothy Prinzing

    70  */

    71 public class DefaultEditorKit extends EditorKit {

    72 

    73     /**

    74      * default constructor for DefaultEditorKit

    75      */

    76     public DefaultEditorKit() {

    77     }

    78 

    79     /**

    80      * Gets the MIME type of the data that this

    81      * kit represents support for.  The default

    82      * is <code>text/plain</code>.

    83      *

    84      * @return the type

    85      */

    86     public String getContentType() {

    87         return "text/plain";

    88     }

    89 

    90     /**

    91      * Fetches a factory that is suitable for producing

    92      * views of any models that are produced by this

    93      * kit.  The default is to have the UI produce the

    94      * factory, so this method has no implementation.

    95      *

    96      * @return the view factory

    97      */

    98     public ViewFactory getViewFactory() {

    99         return null;

   100     }

   101 

   102     /**

   103      * Fetches the set of commands that can be used

   104      * on a text component that is using a model and

   105      * view produced by this kit.

   106      *

   107      * @return the command list

   108      */

   109     public Action[] getActions() {

   110         return defaultActions;

   111     }

   112 

   113     /**

   114      * Fetches a caret that can navigate through views

   115      * produced by the associated ViewFactory.

   116      *

   117      * @return the caret

   118      */

   119     public Caret createCaret() {

   120         return null;

   121     }

   122 

   123     /**

   124      * Creates an uninitialized text storage model (PlainDocument)

   125      * that is appropriate for this type of editor.

   126      *

   127      * @return the model

   128      */

   129     public Document createDefaultDocument() {

   130         return new PlainDocument();

   131     }

   132 

   133     /**

   134      * Inserts content from the given stream which is expected

   135      * to be in a format appropriate for this kind of content

   136      * handler.

   137      *

   138      * @param in  The stream to read from

   139      * @param doc The destination for the insertion.

   140      * @param pos The location in the document to place the

   141      *   content >= 0.

   142      * @exception IOException on any I/O error

   143      * @exception BadLocationException if pos represents an invalid

   144      *   location within the document.

   145      */

   146     public void read(InputStream in, Document doc, int pos)

   147         throws IOException, BadLocationException {

   148 

   149         read(new InputStreamReader(in), doc, pos);

   150     }

   151 

   152     /**

   153      * Writes content from a document to the given stream

   154      * in a format appropriate for this kind of content handler.

   155      *

   156      * @param out The stream to write to

   157      * @param doc The source for the write.

   158      * @param pos The location in the document to fetch the

   159      *   content >= 0.

   160      * @param len The amount to write out >= 0.

   161      * @exception IOException on any I/O error

   162      * @exception BadLocationException if pos represents an invalid

   163      *   location within the document.

   164      */

   165     public void write(OutputStream out, Document doc, int pos, int len)

   166         throws IOException, BadLocationException {

   167         OutputStreamWriter osw = new OutputStreamWriter(out);

   168 

   169         write(osw, doc, pos, len);

   170         osw.flush();

   171     }

   172 

   173     /**

   174      * Gets the input attributes for the pane. This method exists for

   175      * the benefit of StyledEditorKit so that the read method will

   176      * pick up the correct attributes to apply to inserted text.

   177      * This class's implementation simply returns null.

   178      *

   179      * @return null

   180      */

   181     MutableAttributeSet getInputAttributes() {

   182         return null;

   183     }

   184 

   185     /**

   186      * Inserts content from the given stream, which will be

   187      * treated as plain text.

   188      *

   189      * @param in  The stream to read from

   190      * @param doc The destination for the insertion.

   191      * @param pos The location in the document to place the

   192      *   content >= 0.

   193      * @exception IOException on any I/O error

   194      * @exception BadLocationException if pos represents an invalid

   195      *   location within the document.

   196      */

   197     public void read(Reader in, Document doc, int pos)

   198         throws IOException, BadLocationException {

   199 

   200         char[] buff = new char[4096];

   201         int nch;

   202         boolean lastWasCR = false;

   203         boolean isCRLF = false;

   204         boolean isCR = false;

   205         int last;

   206         boolean wasEmpty = (doc.getLength() == 0);

   207         AttributeSet attr = getInputAttributes();

   208 

   209         // Read in a block at a time, mapping \r\n to \n, as well as single

   210         // \r's to \n's. If a \r\n is encountered, \r\n will be set as the

   211         // newline string for the document, if \r is encountered it will

   212         // be set as the newline character, otherwise the newline property

   213         // for the document will be removed.

   214         while ((nch = in.read(buff, 0, buff.length)) != -1) {

   215             last = 0;

   216             for(int counter = 0; counter < nch; counter++) {

   217                 switch(buff[counter]) {

   218                 case '\r':

   219                     if (lastWasCR) {

   220                         isCR = true;

   221                         if (counter == 0) {

   222                             doc.insertString(pos, "\n", attr);

   223                             pos++;

   224                         }

   225                         else {

   226                             buff[counter - 1] = '\n';

   227                         }

   228                     }

   229                     else {

   230                         lastWasCR = true;

   231                     }

   232                     break;

   233                 case '\n':

   234                     if (lastWasCR) {

   235                         if (counter > (last + 1)) {

   236                             doc.insertString(pos, new String(buff, last,

   237                                             counter - last - 1), attr);

   238                             pos += (counter - last - 1);

   239                         }

   240                         // else nothing to do, can skip \r, next write will

   241                         // write \n

   242                         lastWasCR = false;

   243                         last = counter;

   244                         isCRLF = true;

   245                     }

   246                     break;

   247                 default:

   248                     if (lastWasCR) {

   249                         isCR = true;

   250                         if (counter == 0) {

   251                             doc.insertString(pos, "\n", attr);

   252                             pos++;

   253                         }

   254                         else {

   255                             buff[counter - 1] = '\n';

   256                         }

   257                         lastWasCR = false;

   258                     }

   259                     break;

   260                 }

   261             }

   262             if (last < nch) {

   263                 if(lastWasCR) {

   264                     if (last < (nch - 1)) {

   265                         doc.insertString(pos, new String(buff, last,

   266                                          nch - last - 1), attr);

   267                         pos += (nch - last - 1);

   268                     }

   269                 }

   270                 else {

   271                     doc.insertString(pos, new String(buff, last,

   272                                      nch - last), attr);

   273                     pos += (nch - last);

   274                 }

   275             }

   276         }

   277         if (lastWasCR) {

   278             doc.insertString(pos, "\n", attr);

   279             isCR = true;

   280         }

   281         if (wasEmpty) {

   282             if (isCRLF) {

   283                 doc.putProperty(EndOfLineStringProperty, "\r\n");

   284             }

   285             else if (isCR) {

   286                 doc.putProperty(EndOfLineStringProperty, "\r");

   287             }

   288             else {

   289                 doc.putProperty(EndOfLineStringProperty, "\n");

   290             }

   291         }

   292     }

   293 

   294     /**

   295      * Writes content from a document to the given stream

   296      * as plain text.

   297      *

   298      * @param out  The stream to write to

   299      * @param doc The source for the write.

   300      * @param pos The location in the document to fetch the

   301      *   content from >= 0.

   302      * @param len The amount to write out >= 0.

   303      * @exception IOException on any I/O error

   304      * @exception BadLocationException if pos is not within 0 and

   305      *   the length of the document.

   306      */

   307     public void write(Writer out, Document doc, int pos, int len)

   308         throws IOException, BadLocationException {

   309 

   310         if ((pos < 0) || ((pos + len) > doc.getLength())) {

   311             throw new BadLocationException("DefaultEditorKit.write", pos);

   312         }

   313         Segment data = new Segment();

   314         int nleft = len;

   315         int offs = pos;

   316         Object endOfLineProperty = doc.getProperty(EndOfLineStringProperty);

   317         if (endOfLineProperty == null) {

   318             try {

   319                 endOfLineProperty = System.getProperty("line.separator");

   320             } catch (SecurityException se) { }

   321         }

   322         String endOfLine;

   323         if (endOfLineProperty instanceof String) {

   324             endOfLine = (String)endOfLineProperty;

   325         }

   326         else {

   327             endOfLine = null;

   328         }

   329         if (endOfLineProperty != null && !endOfLine.equals("\n")) {

   330             // There is an end of line string that isn't \n, have to iterate

   331             // through and find all \n's and translate to end of line string.

   332             while (nleft > 0) {

   333                 int n = Math.min(nleft, 4096);

   334                 doc.getText(offs, n, data);

   335                 int last = data.offset;

   336                 char[] array = data.array;

   337                 int maxCounter = last + data.count;

   338                 for (int counter = last; counter < maxCounter; counter++) {

   339                     if (array[counter] == '\n') {

   340                         if (counter > last) {

   341                             out.write(array, last, counter - last);

   342                         }

   343                         out.write(endOfLine);

   344                         last = counter + 1;

   345                     }

   346                 }

   347                 if (maxCounter > last) {

   348                     out.write(array, last, maxCounter - last);

   349                 }

   350                 offs += n;

   351                 nleft -= n;

   352             }

   353         }

   354         else {

   355             // Just write out text, will already have \n, no mapping to

   356             // do.

   357             while (nleft > 0) {

   358                 int n = Math.min(nleft, 4096);

   359                 doc.getText(offs, n, data);

   360                 out.write(data.array, data.offset, data.count);

   361                 offs += n;

   362                 nleft -= n;

   363             }

   364         }

   365         out.flush();

   366     }

   367 

   368 

   369     /**

   370      * When reading a document if a CRLF is encountered a property

   371      * with this name is added and the value will be "\r\n".

   372      */

   373     public static final String EndOfLineStringProperty = "__EndOfLine__";

   374 

   375     // --- names of well-known actions ---------------------------

   376 

   377     /**

   378      * Name of the action to place content into the associated

   379      * document.  If there is a selection, it is removed before

   380      * the new content is added.

   381      * @see #getActions

   382      */

   383     public static final String insertContentAction = "insert-content";

   384 

   385     /**

   386      * Name of the action to place a line/paragraph break into

   387      * the document.  If there is a selection, it is removed before

   388      * the break is added.

   389      * @see #getActions

   390      */

   391     public static final String insertBreakAction = "insert-break";

   392 

   393     /**

   394      * Name of the action to place a tab character into

   395      * the document.  If there is a selection, it is removed before

   396      * the tab is added.

   397      * @see #getActions

   398      */

   399     public static final String insertTabAction = "insert-tab";

   400 

   401     /**

   402      * Name of the action to delete the character of content that

   403      * precedes the current caret position.

   404      * @see #getActions

   405      */

   406     public static final String deletePrevCharAction = "delete-previous";

   407 

   408     /**

   409      * Name of the action to delete the character of content that

   410      * follows the current caret position.

   411      * @see #getActions

   412      */

   413     public static final String deleteNextCharAction = "delete-next";

   414 

   415     /**

   416      * Name of the action to delete the word that

   417      * follows the beginning of the selection.

   418      * @see #getActions

   419      * @see JTextComponent#getSelectionStart

   420      * @since 1.6

   421      */

   422     public static final String deleteNextWordAction = "delete-next-word";

   423 

   424     /**

   425      * Name of the action to delete the word that

   426      * precedes the beginning of the selection.

   427      * @see #getActions

   428      * @see JTextComponent#getSelectionStart

   429      * @since 1.6

   430      */

   431     public static final String deletePrevWordAction = "delete-previous-word";

   432 

   433     /**

   434      * Name of the action to set the editor into read-only

   435      * mode.

   436      * @see #getActions

   437      */

   438     public static final String readOnlyAction = "set-read-only";

   439 

   440     /**

   441      * Name of the action to set the editor into writeable

   442      * mode.

   443      * @see #getActions

   444      */

   445     public static final String writableAction = "set-writable";

   446 

   447     /**

   448      * Name of the action to cut the selected region

   449      * and place the contents into the system clipboard.

   450      * @see JTextComponent#cut

   451      * @see #getActions

   452      */

   453     public static final String cutAction = "cut-to-clipboard";

   454 

   455     /**

   456      * Name of the action to copy the selected region

   457      * and place the contents into the system clipboard.

   458      * @see JTextComponent#copy

   459      * @see #getActions

   460      */

   461     public static final String copyAction = "copy-to-clipboard";

   462 

   463     /**

   464      * Name of the action to paste the contents of the

   465      * system clipboard into the selected region, or before the

   466      * caret if nothing is selected.

   467      * @see JTextComponent#paste

   468      * @see #getActions

   469      */

   470     public static final String pasteAction = "paste-from-clipboard";

   471 

   472     /**

   473      * Name of the action to create a beep.

   474      * @see #getActions

   475      */

   476     public static final String beepAction = "beep";

   477 

   478     /**

   479      * Name of the action to page up vertically.

   480      * @see #getActions

   481      */

   482     public static final String pageUpAction = "page-up";

   483 

   484     /**

   485      * Name of the action to page down vertically.

   486      * @see #getActions

   487      */

   488     public static final String pageDownAction = "page-down";

   489 

   490     /**

   491      * Name of the action to page up vertically, and move the

   492      * selection.

   493      * @see #getActions

   494      */

   495     /*public*/ static final String selectionPageUpAction = "selection-page-up";

   496 

   497     /**

   498      * Name of the action to page down vertically, and move the

   499      * selection.

   500      * @see #getActions

   501      */

   502     /*public*/ static final String selectionPageDownAction = "selection-page-down";

   503 

   504     /**

   505      * Name of the action to page left horizontally, and move the

   506      * selection.

   507      * @see #getActions

   508      */

   509     /*public*/ static final String selectionPageLeftAction = "selection-page-left";

   510 

   511     /**

   512      * Name of the action to page right horizontally, and move the

   513      * selection.

   514      * @see #getActions

   515      */

   516     /*public*/ static final String selectionPageRightAction = "selection-page-right";

   517 

   518     /**

   519      * Name of the Action for moving the caret

   520      * logically forward one position.

   521      * @see #getActions

   522      */

   523     public static final String forwardAction = "caret-forward";

   524 

   525     /**

   526      * Name of the Action for moving the caret

   527      * logically backward one position.

   528      * @see #getActions

   529      */

   530     public static final String backwardAction = "caret-backward";

   531 

   532     /**

   533      * Name of the Action for extending the selection

   534      * by moving the caret logically forward one position.

   535      * @see #getActions

   536      */

   537     public static final String selectionForwardAction = "selection-forward";

   538 

   539     /**

   540      * Name of the Action for extending the selection

   541      * by moving the caret logically backward one position.

   542      * @see #getActions

   543      */

   544     public static final String selectionBackwardAction = "selection-backward";

   545 

   546     /**

   547      * Name of the Action for moving the caret

   548      * logically upward one position.

   549      * @see #getActions

   550      */

   551     public static final String upAction = "caret-up";

   552 

   553     /**

   554      * Name of the Action for moving the caret

   555      * logically downward one position.

   556      * @see #getActions

   557      */

   558     public static final String downAction = "caret-down";

   559 

   560     /**

   561      * Name of the Action for moving the caret

   562      * logically upward one position, extending the selection.

   563      * @see #getActions

   564      */

   565     public static final String selectionUpAction = "selection-up";

   566 

   567     /**

   568      * Name of the Action for moving the caret

   569      * logically downward one position, extending the selection.

   570      * @see #getActions

   571      */

   572     public static final String selectionDownAction = "selection-down";

   573 

   574     /**

   575      * Name of the <code>Action</code> for moving the caret

   576      * to the beginning of a word.

   577      * @see #getActions

   578      */

   579     public static final String beginWordAction = "caret-begin-word";

   580 

   581     /**

   582      * Name of the Action for moving the caret

   583      * to the end of a word.

   584      * @see #getActions

   585      */

   586     public static final String endWordAction = "caret-end-word";

   587 

   588     /**

   589      * Name of the <code>Action</code> for moving the caret

   590      * to the beginning of a word, extending the selection.

   591      * @see #getActions

   592      */

   593     public static final String selectionBeginWordAction = "selection-begin-word";

   594 

   595     /**

   596      * Name of the Action for moving the caret

   597      * to the end of a word, extending the selection.

   598      * @see #getActions

   599      */

   600     public static final String selectionEndWordAction = "selection-end-word";

   601 

   602     /**

   603      * Name of the <code>Action</code> for moving the caret to the

   604      * beginning of the previous word.

   605      * @see #getActions

   606      */

   607     public static final String previousWordAction = "caret-previous-word";

   608 

   609     /**

   610      * Name of the <code>Action</code> for moving the caret to the

   611      * beginning of the next word.

   612      * @see #getActions

   613      */

   614     public static final String nextWordAction = "caret-next-word";

   615 

   616     /**

   617      * Name of the <code>Action</code> for moving the selection to the

   618      * beginning of the previous word, extending the selection.

   619      * @see #getActions

   620      */

   621     public static final String selectionPreviousWordAction = "selection-previous-word";

   622 

   623     /**

   624      * Name of the <code>Action</code> for moving the selection to the

   625      * beginning of the next word, extending the selection.

   626      * @see #getActions

   627      */

   628     public static final String selectionNextWordAction = "selection-next-word";

   629 

   630     /**

   631      * Name of the <code>Action</code> for moving the caret

   632      * to the beginning of a line.

   633      * @see #getActions

   634      */

   635     public static final String beginLineAction = "caret-begin-line";

   636 

   637     /**

   638      * Name of the <code>Action</code> for moving the caret

   639      * to the end of a line.

   640      * @see #getActions

   641      */

   642     public static final String endLineAction = "caret-end-line";

   643 

   644     /**

   645      * Name of the <code>Action</code> for moving the caret

   646      * to the beginning of a line, extending the selection.

   647      * @see #getActions

   648      */

   649     public static final String selectionBeginLineAction = "selection-begin-line";

   650 

   651     /**

   652      * Name of the <code>Action</code> for moving the caret

   653      * to the end of a line, extending the selection.

   654      * @see #getActions

   655      */

   656     public static final String selectionEndLineAction = "selection-end-line";

   657 

   658     /**

   659      * Name of the <code>Action</code> for moving the caret

   660      * to the beginning of a paragraph.

   661      * @see #getActions

   662      */

   663     public static final String beginParagraphAction = "caret-begin-paragraph";

   664 

   665     /**

   666      * Name of the <code>Action</code> for moving the caret

   667      * to the end of a paragraph.

   668      * @see #getActions

   669      */

   670     public static final String endParagraphAction = "caret-end-paragraph";

   671 

   672     /**

   673      * Name of the <code>Action</code> for moving the caret

   674      * to the beginning of a paragraph, extending the selection.

   675      * @see #getActions

   676      */

   677     public static final String selectionBeginParagraphAction = "selection-begin-paragraph";

   678 

   679     /**

   680      * Name of the <code>Action</code> for moving the caret

   681      * to the end of a paragraph, extending the selection.

   682      * @see #getActions

   683      */

   684     public static final String selectionEndParagraphAction = "selection-end-paragraph";

   685 

   686     /**

   687      * Name of the <code>Action</code> for moving the caret

   688      * to the beginning of the document.

   689      * @see #getActions

   690      */

   691     public static final String beginAction = "caret-begin";

   692 

   693     /**

   694      * Name of the <code>Action</code> for moving the caret

   695      * to the end of the document.

   696      * @see #getActions

   697      */

   698     public static final String endAction = "caret-end";

   699 

   700     /**

   701      * Name of the <code>Action</code> for moving the caret

   702      * to the beginning of the document.

   703      * @see #getActions

   704      */

   705     public static final String selectionBeginAction = "selection-begin";

   706 

   707     /**

   708      * Name of the Action for moving the caret

   709      * to the end of the document.

   710      * @see #getActions

   711      */

   712     public static final String selectionEndAction = "selection-end";

   713 

   714     /**

   715      * Name of the Action for selecting a word around the caret.

   716      * @see #getActions

   717      */

   718     public static final String selectWordAction = "select-word";

   719 

   720     /**

   721      * Name of the Action for selecting a line around the caret.

   722      * @see #getActions

   723      */

   724     public static final String selectLineAction = "select-line";

   725 

   726     /**

   727      * Name of the Action for selecting a paragraph around the caret.

   728      * @see #getActions

   729      */

   730     public static final String selectParagraphAction = "select-paragraph";

   731 

   732     /**

   733      * Name of the Action for selecting the entire document

   734      * @see #getActions

   735      */

   736     public static final String selectAllAction = "select-all";

   737 

   738     /**

   739      * Name of the Action for removing selection

   740      * @see #getActions

   741      */

   742     /*public*/ static final String unselectAction = "unselect";

   743 

   744     /**

   745      * Name of the Action for toggling the component's orientation.

   746      * @see #getActions

   747      */

   748     /*public*/ static final String toggleComponentOrientationAction

   749         = "toggle-componentOrientation";

   750 

   751     /**

   752      * Name of the action that is executed by default if

   753      * a <em>key typed event</em> is received and there

   754      * is no keymap entry.

   755      * @see #getActions

   756      */

   757     public static final String defaultKeyTypedAction = "default-typed";

   758 

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

   760 

   761     private static final Action[] defaultActions = {

   762         new InsertContentAction(), new DeletePrevCharAction(),

   763         new DeleteNextCharAction(), new ReadOnlyAction(),

   764         new DeleteWordAction(deletePrevWordAction),

   765         new DeleteWordAction(deleteNextWordAction),

   766         new WritableAction(), new CutAction(),

   767         new CopyAction(), new PasteAction(),

   768         new VerticalPageAction(pageUpAction, -1, false),

   769         new VerticalPageAction(pageDownAction, 1, false),

   770         new VerticalPageAction(selectionPageUpAction, -1, true),

   771         new VerticalPageAction(selectionPageDownAction, 1, true),

   772         new PageAction(selectionPageLeftAction, true, true),

   773         new PageAction(selectionPageRightAction, false, true),

   774         new InsertBreakAction(), new BeepAction(),

   775         new NextVisualPositionAction(forwardAction, false,

   776                                      SwingConstants.EAST),

   777         new NextVisualPositionAction(backwardAction, false,

   778                                      SwingConstants.WEST),

   779         new NextVisualPositionAction(selectionForwardAction, true,

   780                                      SwingConstants.EAST),

   781         new NextVisualPositionAction(selectionBackwardAction, true,

   782                                      SwingConstants.WEST),

   783         new NextVisualPositionAction(upAction, false,

   784                                      SwingConstants.NORTH),

   785         new NextVisualPositionAction(downAction, false,

   786                                      SwingConstants.SOUTH),

   787         new NextVisualPositionAction(selectionUpAction, true,

   788                                      SwingConstants.NORTH),

   789         new NextVisualPositionAction(selectionDownAction, true,

   790                                      SwingConstants.SOUTH),

   791         new BeginWordAction(beginWordAction, false),

   792         new EndWordAction(endWordAction, false),

   793         new BeginWordAction(selectionBeginWordAction, true),

   794         new EndWordAction(selectionEndWordAction, true),

   795         new PreviousWordAction(previousWordAction, false),

   796         new NextWordAction(nextWordAction, false),

   797         new PreviousWordAction(selectionPreviousWordAction, true),

   798         new NextWordAction(selectionNextWordAction, true),

   799         new BeginLineAction(beginLineAction, false),

   800         new EndLineAction(endLineAction, false),

   801         new BeginLineAction(selectionBeginLineAction, true),

   802         new EndLineAction(selectionEndLineAction, true),

   803         new BeginParagraphAction(beginParagraphAction, false),

   804         new EndParagraphAction(endParagraphAction, false),

   805         new BeginParagraphAction(selectionBeginParagraphAction, true),

   806         new EndParagraphAction(selectionEndParagraphAction, true),

   807         new BeginAction(beginAction, false),

   808         new EndAction(endAction, false),

   809         new BeginAction(selectionBeginAction, true),

   810         new EndAction(selectionEndAction, true),

   811         new DefaultKeyTypedAction(), new InsertTabAction(),

   812         new SelectWordAction(), new SelectLineAction(),

   813         new SelectParagraphAction(), new SelectAllAction(),

   814         new UnselectAction(), new ToggleComponentOrientationAction(),

   815         new DumpModelAction()

   816     };

   817 

   818     /**

   819      * The action that is executed by default if

   820      * a <em>key typed event</em> is received and there

   821      * is no keymap entry.  There is a variation across

   822      * different VM's in what gets sent as a <em>key typed</em>

   823      * event, and this action tries to filter out the undesired

   824      * events.  This filters the control characters and those

   825      * with the ALT modifier.  It allows Control-Alt sequences

   826      * through as these form legitimate unicode characters on

   827      * some PC keyboards.

   828      * <p>

   829      * If the event doesn't get filtered, it will try to insert

   830      * content into the text editor.  The content is fetched

   831      * from the command string of the ActionEvent.  The text

   832      * entry is done through the <code>replaceSelection</code>

   833      * method on the target text component.  This is the

   834      * action that will be fired for most text entry tasks.

   835      * <p>

   836      * <strong>Warning:</strong>

   837      * Serialized objects of this class will not be compatible with

   838      * future Swing releases. The current serialization support is

   839      * appropriate for short term storage or RMI between applications running

   840      * the same version of Swing.  As of 1.4, support for long term storage

   841      * of all JavaBeans<sup><font size="-2">TM</font></sup>

   842      * has been added to the <code>java.beans</code> package.

   843      * Please see {@link java.beans.XMLEncoder}.

   844      *

   845      * @see DefaultEditorKit#defaultKeyTypedAction

   846      * @see DefaultEditorKit#getActions

   847      * @see Keymap#setDefaultAction

   848      * @see Keymap#getDefaultAction

   849      */

   850     public static class DefaultKeyTypedAction extends TextAction {

   851 

   852         /**

   853          * Creates this object with the appropriate identifier.

   854          */

   855         public DefaultKeyTypedAction() {

   856             super(defaultKeyTypedAction);

   857         }

   858 

   859         /**

   860          * The operation to perform when this action is triggered.

   861          *

   862          * @param e the action event

   863          */

   864         public void actionPerformed(ActionEvent e) {

   865             JTextComponent target = getTextComponent(e);

   866             if ((target != null) && (e != null)) {

   867                 if ((! target.isEditable()) || (! target.isEnabled())) {

   868                     return;

   869                 }

   870                 String content = e.getActionCommand();

   871                 int mod = e.getModifiers();

   872                 if ((content != null) && (content.length() > 0) &&

   873                     ((mod & ActionEvent.ALT_MASK) == (mod & ActionEvent.CTRL_MASK))) {

   874                     char c = content.charAt(0);

   875                     if ((c >= 0x20) && (c != 0x7F)) {

   876                         target.replaceSelection(content);

   877                     }

   878                 }

   879             }

   880         }

   881     }

   882 

   883     /**

   884      * Places content into the associated document.

   885      * If there is a selection, it is removed before

   886      * the new content is added.

   887      * <p>

   888      * <strong>Warning:</strong>

   889      * Serialized objects of this class will not be compatible with

   890      * future Swing releases. The current serialization support is

   891      * appropriate for short term storage or RMI between applications running

   892      * the same version of Swing.  As of 1.4, support for long term storage

   893      * of all JavaBeans<sup><font size="-2">TM</font></sup>

   894      * has been added to the <code>java.beans</code> package.

   895      * Please see {@link java.beans.XMLEncoder}.

   896      *

   897      * @see DefaultEditorKit#insertContentAction

   898      * @see DefaultEditorKit#getActions

   899      */

   900     public static class InsertContentAction extends TextAction {

   901 

   902         /**

   903          * Creates this object with the appropriate identifier.

   904          */

   905         public InsertContentAction() {

   906             super(insertContentAction);

   907         }

   908 

   909         /**

   910          * The operation to perform when this action is triggered.

   911          *

   912          * @param e the action event

   913          */

   914         public void actionPerformed(ActionEvent e) {

   915             JTextComponent target = getTextComponent(e);

   916             if ((target != null) && (e != null)) {

   917                 if ((! target.isEditable()) || (! target.isEnabled())) {

   918                     UIManager.getLookAndFeel().provideErrorFeedback(target);

   919                     return;

   920                 }

   921                 String content = e.getActionCommand();

   922                 if (content != null) {

   923                     target.replaceSelection(content);

   924                 } else {

   925                     UIManager.getLookAndFeel().provideErrorFeedback(target);

   926                 }

   927             }

   928         }

   929     }

   930 

   931     /**

   932      * Places a line/paragraph break into the document.

   933      * If there is a selection, it is removed before

   934      * the break is added.

   935      * <p>

   936      * <strong>Warning:</strong>

   937      * Serialized objects of this class will not be compatible with

   938      * future Swing releases. The current serialization support is

   939      * appropriate for short term storage or RMI between applications running

   940      * the same version of Swing.  As of 1.4, support for long term storage

   941      * of all JavaBeans<sup><font size="-2">TM</font></sup>

   942      * has been added to the <code>java.beans</code> package.

   943      * Please see {@link java.beans.XMLEncoder}.

   944      *

   945      * @see DefaultEditorKit#insertBreakAction

   946      * @see DefaultEditorKit#getActions

   947      */

   948     public static class InsertBreakAction extends TextAction {

   949 

   950         /**

   951          * Creates this object with the appropriate identifier.

   952          */

   953         public InsertBreakAction() {

   954             super(insertBreakAction);

   955         }

   956 

   957         /**

   958          * The operation to perform when this action is triggered.

   959          *

   960          * @param e the action event

   961          */

   962         public void actionPerformed(ActionEvent e) {

   963             JTextComponent target = getTextComponent(e);

   964             if (target != null) {

   965                 if ((! target.isEditable()) || (! target.isEnabled())) {

   966                     UIManager.getLookAndFeel().provideErrorFeedback(target);

   967                     return;

   968                 }

   969                 target.replaceSelection("\n");

   970             }

   971         }

   972     }

   973 

   974     /**

   975      * Places a tab character into the document. If there

   976      * is a selection, it is removed before the tab is added.

   977      * <p>

   978      * <strong>Warning:</strong>

   979      * Serialized objects of this class will not be compatible with

   980      * future Swing releases. The current serialization support is

   981      * appropriate for short term storage or RMI between applications running

   982      * the same version of Swing.  As of 1.4, support for long term storage

   983      * of all JavaBeans<sup><font size="-2">TM</font></sup>

   984      * has been added to the <code>java.beans</code> package.

   985      * Please see {@link java.beans.XMLEncoder}.

   986      *

   987      * @see DefaultEditorKit#insertTabAction

   988      * @see DefaultEditorKit#getActions

   989      */

   990     public static class InsertTabAction extends TextAction {

   991 

   992         /**

   993          * Creates this object with the appropriate identifier.

   994          */

   995         public InsertTabAction() {

   996             super(insertTabAction);

   997         }

   998 

   999         /**

  1000          * The operation to perform when this action is triggered.

  1001          *

  1002          * @param e the action event

  1003          */

  1004         public void actionPerformed(ActionEvent e) {

  1005             JTextComponent target = getTextComponent(e);

  1006             if (target != null) {

  1007                 if ((! target.isEditable()) || (! target.isEnabled())) {

  1008                     UIManager.getLookAndFeel().provideErrorFeedback(target);

  1009                     return;

  1010                 }

  1011                 target.replaceSelection("\t");

  1012             }

  1013         }

  1014     }

  1015 

  1016     /*

  1017      * Deletes the character of content that precedes the

  1018      * current caret position.

  1019      * @see DefaultEditorKit#deletePrevCharAction

  1020      * @see DefaultEditorKit#getActions

  1021      */

  1022     static class DeletePrevCharAction extends TextAction {

  1023 

  1024         /**

  1025          * Creates this object with the appropriate identifier.

  1026          */

  1027         DeletePrevCharAction() {

  1028             super(deletePrevCharAction);

  1029         }

  1030 

  1031         /**

  1032          * The operation to perform when this action is triggered.

  1033          *

  1034          * @param e the action event

  1035          */

  1036         public void actionPerformed(ActionEvent e) {

  1037             JTextComponent target = getTextComponent(e);

  1038             boolean beep = true;

  1039             if ((target != null) && (target.isEditable())) {

  1040                 try {

  1041                     Document doc = target.getDocument();

  1042                     Caret caret = target.getCaret();

  1043                     int dot = caret.getDot();

  1044                     int mark = caret.getMark();

  1045                     if (dot != mark) {

  1046                         doc.remove(Math.min(dot, mark), Math.abs(dot - mark));

  1047                         beep = false;

  1048                     } else if (dot > 0) {

  1049                         int delChars = 1;

  1050 

  1051                         if (dot > 1) {

  1052                             String dotChars = doc.getText(dot - 2, 2);

  1053                             char c0 = dotChars.charAt(0);

  1054                             char c1 = dotChars.charAt(1);

  1055 

  1056                             if (c0 >= '\uD800' && c0 <= '\uDBFF' &&

  1057                                 c1 >= '\uDC00' && c1 <= '\uDFFF') {

  1058                                 delChars = 2;

  1059                             }

  1060                         }

  1061 

  1062                         doc.remove(dot - delChars, delChars);

  1063                         beep = false;

  1064                     }

  1065                 } catch (BadLocationException bl) {

  1066                 }

  1067             }

  1068             if (beep) {

  1069                 UIManager.getLookAndFeel().provideErrorFeedback(target);

  1070             }

  1071         }

  1072     }

  1073 

  1074     /*

  1075      * Deletes the character of content that follows the

  1076      * current caret position.

  1077      * @see DefaultEditorKit#deleteNextCharAction

  1078      * @see DefaultEditorKit#getActions

  1079      */

  1080     static class DeleteNextCharAction extends TextAction {

  1081 

  1082         /* Create this object with the appropriate identifier. */

  1083         DeleteNextCharAction() {

  1084             super(deleteNextCharAction);

  1085         }

  1086 

  1087         /** The operation to perform when this action is triggered. */

  1088         public void actionPerformed(ActionEvent e) {

  1089             JTextComponent target = getTextComponent(e);

  1090             boolean beep = true;

  1091             if ((target != null) && (target.isEditable())) {

  1092                 try {

  1093                     Document doc = target.getDocument();

  1094                     Caret caret = target.getCaret();

  1095                     int dot = caret.getDot();

  1096                     int mark = caret.getMark();

  1097                     if (dot != mark) {

  1098                         doc.remove(Math.min(dot, mark), Math.abs(dot - mark));

  1099                         beep = false;

  1100                     } else if (dot < doc.getLength()) {

  1101                         int delChars = 1;

  1102 

  1103                         if (dot < doc.getLength() - 1) {

  1104                             String dotChars = doc.getText(dot, 2);

  1105                             char c0 = dotChars.charAt(0);

  1106                             char c1 = dotChars.charAt(1);

  1107 

  1108                             if (c0 >= '\uD800' && c0 <= '\uDBFF' &&

  1109                                 c1 >= '\uDC00' && c1 <= '\uDFFF') {

  1110                                 delChars = 2;

  1111                             }

  1112                         }

  1113 

  1114                         doc.remove(dot, delChars);

  1115                         beep = false;

  1116                     }

  1117                 } catch (BadLocationException bl) {

  1118                 }

  1119             }

  1120             if (beep) {

  1121                 UIManager.getLookAndFeel().provideErrorFeedback(target);

  1122             }

  1123         }

  1124     }

  1125 

  1126 

  1127     /*

  1128      * Deletes the word that precedes/follows the beginning of the selection.

  1129      * @see DefaultEditorKit#getActions

  1130      */

  1131     static class DeleteWordAction extends TextAction {

  1132         DeleteWordAction(String name) {

  1133             super(name);

  1134             assert (name == deletePrevWordAction)

  1135                 || (name == deleteNextWordAction);