1 /*

     2  * Copyright (c) 1997, 2014, Oracle and/or its affiliates. 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.  Oracle designates this

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

     9  * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 package javax.swing.text;

    26 

    27 import sun.awt.SunToolkit;

    28 

    29 import java.io.*;

    30 import java.awt.*;

    31 import java.awt.event.ActionEvent;

    32 import java.text.*;

    33 import javax.swing.Action;

    34 import javax.swing.KeyStroke;

    35 import javax.swing.SwingConstants;

    36 import javax.swing.UIManager;

    37 

    38 /**

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

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

    41  * of text document.  This implementation provides a default

    42  * implementation which treats text as plain text and

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

    44  *

    45  * <dl>

    46  * <dt><b>Newlines</b>

    47  * <dd>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    64  * document.

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

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

    67  * methods.  Subclasses may override this behavior.

    68  *

    69  * </dl>

    70  *

    71  * @author  Timothy Prinzing

    72  */

    73 @SuppressWarnings("serial") // Same-version serialization only

    74 public class DefaultEditorKit extends EditorKit {

    75 

    76     /**

    77      * default constructor for DefaultEditorKit

    78      */

    79     public DefaultEditorKit() {

    80     }

    81 

    82     /**

    83      * Gets the MIME type of the data that this

    84      * kit represents support for.  The default

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

    86      *

    87      * @return the type

    88      */

    89     public String getContentType() {

    90         return "text/plain";

    91     }

    92 

    93     /**

    94      * Fetches a factory that is suitable for producing

    95      * views of any models that are produced by this

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

    97      * factory, so this method has no implementation.

    98      *

    99      * @return the view factory

   100      */

   101     public ViewFactory getViewFactory() {

   102         return null;

   103     }

   104 

   105     /**

   106      * Fetches the set of commands that can be used

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

   108      * view produced by this kit.

   109      *

   110      * @return the command list

   111      */

   112     public Action[] getActions() {

   113         return defaultActions;

   114     }

   115 

   116     /**

   117      * Fetches a caret that can navigate through views

   118      * produced by the associated ViewFactory.

   119      *

   120      * @return the caret

   121      */

   122     public Caret createCaret() {

   123         return null;

   124     }

   125 

   126     /**

   127      * Creates an uninitialized text storage model (PlainDocument)

   128      * that is appropriate for this type of editor.

   129      *

   130      * @return the model

   131      */

   132     public Document createDefaultDocument() {

   133         return new PlainDocument();

   134     }

   135 

   136     /**

   137      * Inserts content from the given stream which is expected

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

   139      * handler.

   140      *

   141      * @param in  The stream to read from

   142      * @param doc The destination for the insertion.

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

   144      *   content >=0.

   145      * @exception IOException on any I/O error

   146      * @exception BadLocationException if pos represents an invalid

   147      *   location within the document.

   148      */

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

   150         throws IOException, BadLocationException {

   151 

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

   153     }

   154 

   155     /**

   156      * Writes content from a document to the given stream

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

   158      *

   159      * @param out The stream to write to

   160      * @param doc The source for the write.

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

   162      *   content >=0.

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

   164      * @exception IOException on any I/O error

   165      * @exception BadLocationException if pos represents an invalid

   166      *   location within the document.

   167      */

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

   169         throws IOException, BadLocationException {

   170         OutputStreamWriter osw = new OutputStreamWriter(out);

   171 

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

   173         osw.flush();

   174     }

   175 

   176     /**

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

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

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

   180      * This class's implementation simply returns null.

   181      *

   182      * @return null

   183      */

   184     MutableAttributeSet getInputAttributes() {

   185         return null;

   186     }

   187 

   188     /**

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

   190      * treated as plain text.

   191      *

   192      * @param in  The stream to read from

   193      * @param doc The destination for the insertion.

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

   195      *   content >=0.

   196      * @exception IOException on any I/O error

   197      * @exception BadLocationException if pos represents an invalid

   198      *   location within the document.

   199      */

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

   201         throws IOException, BadLocationException {

   202 

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

   204         int nch;

   205         boolean lastWasCR = false;

   206         boolean isCRLF = false;

   207         boolean isCR = false;

   208         int last;

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

   210         AttributeSet attr = getInputAttributes();

   211 

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

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

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

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

   216         // for the document will be removed.

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

   218             last = 0;

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

   220                 switch(buff[counter]) {

   221                 case '\r':

   222                     if (lastWasCR) {

   223                         isCR = true;

   224                         if (counter == 0) {

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

   226                             pos++;

   227                         }

   228                         else {

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

   230                         }

   231                     }

   232                     else {

   233                         lastWasCR = true;

   234                     }

   235                     break;

   236                 case '\n':

   237                     if (lastWasCR) {

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

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

   240                                             counter - last - 1), attr);

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

   242                         }

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

   244                         // write \n

   245                         lastWasCR = false;

   246                         last = counter;

   247                         isCRLF = true;

   248                     }

   249                     break;

   250                 default:

   251                     if (lastWasCR) {

   252                         isCR = true;

   253                         if (counter == 0) {

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

   255                             pos++;

   256                         }

   257                         else {

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

   259                         }

   260                         lastWasCR = false;

   261                     }

   262                     break;

   263                 }

   264             }

   265             if (last < nch) {

   266                 if(lastWasCR) {

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

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

   269                                          nch - last - 1), attr);

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

   271                     }

   272                 }

   273                 else {

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

   275                                      nch - last), attr);

   276                     pos += (nch - last);

   277                 }

   278             }

   279         }

   280         if (lastWasCR) {

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

   282             isCR = true;

   283         }

   284         if (wasEmpty) {

   285             if (isCRLF) {

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

   287             }

   288             else if (isCR) {

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

   290             }

   291             else {

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

   293             }

   294         }

   295     }

   296 

   297     /**

   298      * Writes content from a document to the given stream

   299      * as plain text.

   300      *

   301      * @param out  The stream to write to

   302      * @param doc The source for the write.

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

   304      *   content from >=0.

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

   306      * @exception IOException on any I/O error

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

   308      *   the length of the document.

   309      */

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

   311         throws IOException, BadLocationException {

   312 

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

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

   315         }

   316         Segment data = new Segment();

   317         int nleft = len;

   318         int offs = pos;

   319         Object endOfLineProperty = doc.getProperty(EndOfLineStringProperty);

   320         if (endOfLineProperty == null) {

   321             endOfLineProperty = System.lineSeparator();

   322         }

   323         String endOfLine;

   324         if (endOfLineProperty instanceof String) {

   325             endOfLine = (String)endOfLineProperty;

   326         }

   327         else {

   328             endOfLine = null;

   329         }

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

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

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

   333             while (nleft > 0) {

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

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

   336                 int last = data.offset;

   337                 char[] array = data.array;

   338                 int maxCounter = last + data.count;

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

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

   341                         if (counter > last) {

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

   343                         }

   344                         out.write(endOfLine);

   345                         last = counter + 1;

   346                     }

   347                 }

   348                 if (maxCounter > last) {

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

   350                 }

   351                 offs += n;

   352                 nleft -= n;

   353             }

   354         }

   355         else {

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

   357             // do.

   358             while (nleft > 0) {

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

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

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

   362                 offs += n;

   363                 nleft -= n;

   364             }

   365         }

   366         out.flush();

   367     }

   368 

   369 

   370     /**

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

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

   373      */

   374     public static final String EndOfLineStringProperty = "__EndOfLine__";

   375 

   376     // --- names of well-known actions ---------------------------

   377 

   378     /**

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

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

   381      * the new content is added.

   382      * @see #getActions

   383      */

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

   385 

   386     /**

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

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

   389      * the break is added.

   390      * @see #getActions

   391      */

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

   393 

   394     /**

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

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

   397      * the tab is added.

   398      * @see #getActions

   399      */

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

   401 

   402     /**

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

   404      * precedes the current caret position.

   405      * @see #getActions

   406      */

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

   408 

   409     /**

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

   411      * follows the current caret position.

   412      * @see #getActions

   413      */

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

   415 

   416     /**

   417      * Name of the action to delete the word that

   418      * follows the beginning of the selection.

   419      * @see #getActions

   420      * @see JTextComponent#getSelectionStart

   421      * @since 1.6

   422      */

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

   424 

   425     /**

   426      * Name of the action to delete the word that

   427      * precedes the beginning of the selection.

   428      * @see #getActions

   429      * @see JTextComponent#getSelectionStart

   430      * @since 1.6

   431      */

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

   433 

   434     /**

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

   436      * mode.

   437      * @see #getActions

   438      */

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

   440 

   441     /**

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

   443      * mode.

   444      * @see #getActions

   445      */

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

   447 

   448     /**

   449      * Name of the action to cut the selected region

   450      * and place the contents into the system clipboard.

   451      * @see JTextComponent#cut

   452      * @see #getActions

   453      */

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

   455 

   456     /**

   457      * Name of the action to copy the selected region

   458      * and place the contents into the system clipboard.

   459      * @see JTextComponent#copy

   460      * @see #getActions

   461      */

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

   463 

   464     /**

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

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

   467      * caret if nothing is selected.

   468      * @see JTextComponent#paste

   469      * @see #getActions

   470      */

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

   472 

   473     /**

   474      * Name of the action to create a beep.

   475      * @see #getActions

   476      */

   477     public static final String beepAction = "beep";

   478 

   479     /**

   480      * Name of the action to page up vertically.

   481      * @see #getActions

   482      */

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

   484 

   485     /**

   486      * Name of the action to page down vertically.

   487      * @see #getActions

   488      */

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

   490 

   491     /**

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

   493      * selection.

   494      * @see #getActions

   495      */

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

   497 

   498     /**

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

   500      * selection.

   501      * @see #getActions

   502      */

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

   504 

   505     /**

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

   507      * selection.

   508      * @see #getActions

   509      */

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

   511 

   512     /**

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

   514      * selection.

   515      * @see #getActions

   516      */

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

   518 

   519     /**

   520      * Name of the Action for moving the caret

   521      * logically forward one position.

   522      * @see #getActions

   523      */

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

   525 

   526     /**

   527      * Name of the Action for moving the caret

   528      * logically backward one position.

   529      * @see #getActions

   530      */

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

   532 

   533     /**

   534      * Name of the Action for extending the selection

   535      * by moving the caret logically forward one position.

   536      * @see #getActions

   537      */

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

   539 

   540     /**

   541      * Name of the Action for extending the selection

   542      * by moving the caret logically backward one position.

   543      * @see #getActions

   544      */

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

   546 

   547     /**

   548      * Name of the Action for moving the caret

   549      * logically upward one position.

   550      * @see #getActions

   551      */

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

   553 

   554     /**

   555      * Name of the Action for moving the caret

   556      * logically downward one position.

   557      * @see #getActions

   558      */

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

   560 

   561     /**

   562      * Name of the Action for moving the caret

   563      * logically upward one position, extending the selection.

   564      * @see #getActions

   565      */

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

   567 

   568     /**

   569      * Name of the Action for moving the caret

   570      * logically downward one position, extending the selection.

   571      * @see #getActions

   572      */

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

   574 

   575     /**

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

   577      * to the beginning of a word.

   578      * @see #getActions

   579      */

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

   581 

   582     /**

   583      * Name of the Action for moving the caret

   584      * to the end of a word.

   585      * @see #getActions

   586      */

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

   588 

   589     /**

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

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

   592      * @see #getActions

   593      */

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

   595 

   596     /**

   597      * Name of the Action for moving the caret

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

   599      * @see #getActions

   600      */

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

   602 

   603     /**

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

   605      * beginning of the previous word.

   606      * @see #getActions

   607      */

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

   609 

   610     /**

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

   612      * beginning of the next word.

   613      * @see #getActions

   614      */

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

   616 

   617     /**

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

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

   620      * @see #getActions

   621      */

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

   623 

   624     /**

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

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

   627      * @see #getActions

   628      */

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

   630 

   631     /**

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

   633      * to the beginning of a line.

   634      * @see #getActions

   635      */

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

   637 

   638     /**

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

   640      * to the end of a line.

   641      * @see #getActions

   642      */

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

   644 

   645     /**

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

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

   648      * @see #getActions

   649      */

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

   651 

   652     /**

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

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

   655      * @see #getActions

   656      */

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

   658 

   659     /**

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

   661      * to the beginning of a paragraph.

   662      * @see #getActions

   663      */

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

   665 

   666     /**

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

   668      * to the end of a paragraph.

   669      * @see #getActions

   670      */

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

   672 

   673     /**

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

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

   676      * @see #getActions

   677      */

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

   679 

   680     /**

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

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

   683      * @see #getActions

   684      */

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

   686 

   687     /**

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

   689      * to the beginning of the document.

   690      * @see #getActions

   691      */

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

   693 

   694     /**

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

   696      * to the end of the document.

   697      * @see #getActions

   698      */

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

   700 

   701     /**

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

   703      * to the beginning of the document.

   704      * @see #getActions

   705      */

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

   707 

   708     /**

   709      * Name of the Action for moving the caret

   710      * to the end of the document.

   711      * @see #getActions

   712      */

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

   714 

   715     /**

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

   717      * @see #getActions

   718      */

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

   720 

   721     /**

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

   723      * @see #getActions

   724      */

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

   726 

   727     /**

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

   729      * @see #getActions

   730      */

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

   732 

   733     /**

   734      * Name of the Action for selecting the entire document

   735      * @see #getActions

   736      */

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

   738 

   739     /**

   740      * Name of the Action for removing selection

   741      * @see #getActions

   742      */

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

   744 

   745     /**

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

   747      * @see #getActions

   748      */

   749     /*public*/ static final String toggleComponentOrientationAction

   750         = "toggle-componentOrientation";

   751 

   752     /**

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

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

   755      * is no keymap entry.

   756      * @see #getActions

   757      */

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

   759 

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

   761 

   762     private static final Action[] defaultActions = {

   763         new InsertContentAction(), new DeletePrevCharAction(),

   764         new DeleteNextCharAction(), new ReadOnlyAction(),

   765         new DeleteWordAction(deletePrevWordAction),

   766         new DeleteWordAction(deleteNextWordAction),

   767         new WritableAction(), new CutAction(),

   768         new CopyAction(), new PasteAction(),

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

   770         new VerticalPageAction(pageDownAction, 1, false),

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

   772         new VerticalPageAction(selectionPageDownAction, 1, true),

   773         new PageAction(selectionPageLeftAction, true, true),

   774         new PageAction(selectionPageRightAction, false, true),

   775         new InsertBreakAction(), new BeepAction(),

   776         new NextVisualPositionAction(forwardAction, false,

   777                                      SwingConstants.EAST),

   778         new NextVisualPositionAction(backwardAction, false,

   779                                      SwingConstants.WEST),

   780         new NextVisualPositionAction(selectionForwardAction, true,

   781                                      SwingConstants.EAST),

   782         new NextVisualPositionAction(selectionBackwardAction, true,

   783                                      SwingConstants.WEST),

   784         new NextVisualPositionAction(upAction, false,

   785                                      SwingConstants.NORTH),

   786         new NextVisualPositionAction(downAction, false,

   787                                      SwingConstants.SOUTH),

   788         new NextVisualPositionAction(selectionUpAction, true,

   789                                      SwingConstants.NORTH),

   790         new NextVisualPositionAction(selectionDownAction, true,

   791                                      SwingConstants.SOUTH),

   792         new BeginWordAction(beginWordAction, false),

   793         new EndWordAction(endWordAction, false),

   794         new BeginWordAction(selectionBeginWordAction, true),

   795         new EndWordAction(selectionEndWordAction, true),

   796         new PreviousWordAction(previousWordAction, false),

   797         new NextWordAction(nextWordAction, false),

   798         new PreviousWordAction(selectionPreviousWordAction, true),

   799         new NextWordAction(selectionNextWordAction, true),

   800         new BeginLineAction(beginLineAction, false),

   801         new EndLineAction(endLineAction, false),

   802         new BeginLineAction(selectionBeginLineAction, true),

   803         new EndLineAction(selectionEndLineAction, true),

   804         new BeginParagraphAction(beginParagraphAction, false),

   805         new EndParagraphAction(endParagraphAction, false),

   806         new BeginParagraphAction(selectionBeginParagraphAction, true),

   807         new EndParagraphAction(selectionEndParagraphAction, true),

   808         new BeginAction(beginAction, false),

   809         new EndAction(endAction, false),

   810         new BeginAction(selectionBeginAction, true),

   811         new EndAction(selectionEndAction, true),

   812         new DefaultKeyTypedAction(), new InsertTabAction(),

   813         new SelectWordAction(), new SelectLineAction(),

   814         new SelectParagraphAction(), new SelectAllAction(),

   815         new UnselectAction(), new ToggleComponentOrientationAction(),

   816         new DumpModelAction()

   817     };

   818 

   819     /**

   820      * The action that is executed by default if

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

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

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

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

   825      * events.  This filters the control characters and those

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

   827      * through as these form legitimate unicode characters on

   828      * some PC keyboards.

   829      * <p>

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

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

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

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

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

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

   836      * <p>

   837      * <strong>Warning:</strong>

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

   839      * future Swing releases. The current serialization support is

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

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

   842      * of all JavaBeans™

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

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

   845      *

   846      * @see DefaultEditorKit#defaultKeyTypedAction

   847      * @see DefaultEditorKit#getActions

   848      * @see Keymap#setDefaultAction

   849      * @see Keymap#getDefaultAction

   850      */

   851     @SuppressWarnings("serial") // Same-version serialization only

   852     public static class DefaultKeyTypedAction extends TextAction {

   853 

   854         /**

   855          * Creates this object with the appropriate identifier.

   856          */

   857         public DefaultKeyTypedAction() {

   858             super(defaultKeyTypedAction);

   859         }

   860 

   861         /**

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

   863          *

   864          * @param e the action event

   865          */

   866         public void actionPerformed(ActionEvent e) {

   867             JTextComponent target = getTextComponent(e);

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

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

   870                     return;

   871                 }

   872                 String content = e.getActionCommand();

   873                 int mod = e.getModifiers();

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

   875                     boolean isPrintableMask = true;

   876                     Toolkit tk = Toolkit.getDefaultToolkit();

   877                     if (tk instanceof SunToolkit) {

   878                         isPrintableMask = ((SunToolkit)tk).isPrintableCharacterModifiersMask(mod);

   879                     }

   880 

   881                     if (isPrintableMask) {

   882                         char c = content.charAt(0);

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

   884                             target.replaceSelection(content);

   885                         }

   886                     }

   887                 }

   888             }

   889         }

   890     }

   891 

   892     /**

   893      * Places content into the associated document.

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

   895      * the new content is added.

   896      * <p>

   897      * <strong>Warning:</strong>

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

   899      * future Swing releases. The current serialization support is

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

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

   902      * of all JavaBeans™

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

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

   905      *

   906      * @see DefaultEditorKit#insertContentAction

   907      * @see DefaultEditorKit#getActions

   908      */

   909     @SuppressWarnings("serial") // Same-version serialization only

   910     public static class InsertContentAction extends TextAction {

   911 

   912         /**

   913          * Creates this object with the appropriate identifier.

   914          */

   915         public InsertContentAction() {

   916             super(insertContentAction);

   917         }

   918 

   919         /**

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

   921          *

   922          * @param e the action event

   923          */

   924         public void actionPerformed(ActionEvent e) {

   925             JTextComponent target = getTextComponent(e);

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

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

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

   929                     return;

   930                 }

   931                 String content = e.getActionCommand();

   932                 if (content != null) {

   933                     target.replaceSelection(content);

   934                 } else {

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

   936                 }

   937             }

   938         }

   939     }

   940 

   941     /**

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

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

   944      * the break is added.

   945      * <p>

   946      * <strong>Warning:</strong>

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

   948      * future Swing releases. The current serialization support is

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

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

   951      * of all JavaBeans™

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

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

   954      *

   955      * @see DefaultEditorKit#insertBreakAction

   956      * @see DefaultEditorKit#getActions

   957      */

   958     @SuppressWarnings("serial") // Same-version serialization only

   959     public static class InsertBreakAction extends TextAction {

   960 

   961         /**

   962          * Creates this object with the appropriate identifier.

   963          */

   964         public InsertBreakAction() {

   965             super(insertBreakAction);

   966         }

   967 

   968         /**

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

   970          *

   971          * @param e the action event

   972          */

   973         public void actionPerformed(ActionEvent e) {

   974             JTextComponent target = getTextComponent(e);

   975             if (target != null) {

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

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

   978                     return;

   979                 }

   980                 target.replaceSelection("\n");

   981             }

   982         }

   983     }

   984 

   985     /**

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

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

   988      * <p>

   989      * <strong>Warning:</strong>

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

   991      * future Swing releases. The current serialization support is

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

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

   994      * of all JavaBeans™

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

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

   997      *

   998      * @see DefaultEditorKit#insertTabAction

   999      * @see DefaultEditorKit#getActions

  1000      */

  1001     @SuppressWarnings("serial") // Same-version serialization only

  1002     public static class InsertTabAction extends TextAction {

  1003 

  1004         /**

  1005          * Creates this object with the appropriate identifier.

  1006          */

  1007         public InsertTabAction() {

  1008             super(insertTabAction);

  1009         }

  1010 

  1011         /**

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

  1013          *

  1014          * @param e the action event

  1015          */

  1016         public void actionPerformed(ActionEvent e) {

  1017             JTextComponent target = getTextComponent(e);

  1018             if (target != null) {

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

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

  1021                     return;

  1022                 }

  1023                 target.replaceSelection("\t");

  1024             }

  1025         }

  1026     }

  1027 

  1028     /*

  1029      * Deletes the character of content that precedes the

  1030      * current caret position.

  1031      * @see DefaultEditorKit#deletePrevCharAction

  1032      * @see DefaultEditorKit#getActions

  1033      */

  1034     @SuppressWarnings("serial") // Superclass is not serializable across versions

  1035     static class DeletePrevCharAction extends TextAction {

  1036 

  1037         /**

  1038          * Creates this object with the appropriate identifier.

  1039          */

  1040         DeletePrevCharAction() {

  1041             super(deletePrevCharAction);

  1042         }

  1043 

  1044         /**

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

  1046          *

  1047          * @param e the action event

  1048          */

  1049         public void actionPerformed(ActionEvent e) {

  1050             JTextComponent target = getTextComponent(e);

  1051             boolean beep = true;

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

  1053                 try {

  1054                     Document doc = target.getDocument();

  1055                     Caret caret = target.getCaret();

  1056                     int dot = caret.getDot();

  1057                     int mark = caret.getMark();

  1058                     if (dot != mark) {

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

  1060                         beep = false;

  1061                     } else if (dot > 0) {

  1062                         int delChars = 1;

  1063 

  1064                         if (dot > 1) {

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

  1066                             char c0 = dotChars.charAt(0);

  1067                             char c1 = dotChars.charAt(1);

  1068 

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

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

  1071                                 delChars = 2;

  1072                             }

  1073                         }

  1074 

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

  1076                         beep = false;

  1077                     }

  1078                 } catch (BadLocationException bl) {

  1079                 }

  1080             }

  1081             if (beep) {

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

  1083             }

  1084         }

  1085     }

  1086 

  1087     /*

  1088      * Deletes the character of content that follows the

  1089      * current caret position.

  1090      * @see DefaultEditorKit#deleteNextCharAction

  1091      * @see DefaultEditorKit#getActions

  1092      */

  1093     @SuppressWarnings("serial") // Superclass is not serializable across versions

  1094     static class DeleteNextCharAction extends TextAction {

  1095 

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

  1097         DeleteNextCharAction() {

  1098             super(deleteNextCharAction);

  1099         }

  1100 

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

  1102         public void actionPerformed(ActionEvent e) {

  1103             JTextComponent target = getTextComponent(e);

  1104             boolean beep = true;

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

  1106                 try {

  1107                     Document doc = target.getDocument();

  1108                     Caret caret = target.getCaret();

  1109                     int dot = caret.getDot();

  1110                     int mark = caret.getMark();

  1111                     if (dot != mark) {

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

  1113                         beep = false;

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

  1115                         int delChars = 1;

  1116 

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

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

  1119                             char c0 = dotChars.charAt(0);

  1120                             char c1 = dotChars.charAt(1);

  1121 

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

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

  1124                                 delChars = 2;

  1125                             }

  1126                         }

  1127 

  1128                         doc.remove(dot, delChars);

  1129                         beep = false;

  1130                     }

  1131                 } catch (BadLocationException bl) {

  1132                 }

  1133             }

  1134             if (beep) {