In this chapter:

• Text package overview
• Date and time editor by David M. Karr

A truly exhaustive discussion of the text package is beyond the scope of this book. However, in this chapter we hope to provide enough information about text components, and their underlying constituents, to leave you with a solid understanding of their inner workings. Picking up where chapter 11 left off, we continue our discussion of the most significant aspects of the text package classes and interfaces. This chapter concludes with an example of a custom text field used for several variations of date and time selection. In the next chapter, we continue our study of text components with the development of a full-featured word processor application. The examples in chapter 20 demonstrate practical applications of many of the complex topics covered in this chapter.

    // from JTextComponent.java
    registerKeyboardAction(focusAction,KeyStroke.getKeyStroke(aKey,ActionEvent.ALT_MASK),
                           JComponent.WHEN_IN_FOCUSED_WINDOW);

  // From AbstractDocument.java
  try {
    readLock();
    // do something
  } finally {
    readUnlock();
  }

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.text.*;

public class DumpDemo extends JFrame
{
  JTextArea m_editor;

  public DumpDemo() {
    m_editor = new JTextArea();
  
    JScrollPane js1 = new JScrollPane(m_editor);
    getContentPane().add(js1, BorderLayout.CENTER);

    JButton dumpButton = new JButton("Dump");
    dumpButton.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {
        ((PlainDocument) m_editor.getDocument()).dump(System.out);
      }
    });

    JPanel buttonPanel = new JPanel();
    buttonPanel.add(dumpButton);

    getContentPane().add(buttonPanel, BorderLayout.SOUTH);

    setSize(300,300);
    setVisible(true);
  }

  public static void main(String[] args) {
    new DumpDemo();
  }   
}

Swing is

powerful!!

<paragraph>

<content>

[0,9][Swing is

]

<content>

[9,20][powerful!!

]

<content>

[20,21][

]

<bidi root>

<bidi level

bidiLevel=0

>

[0,21][Swing is

powerful!!

]

This class extends AbstractDocument and is used by the basic text components: JTextField, JPasswordField, and JTextArea. When enforcing certain input, usually in a JTextField, we normally override AbstractDocument’s insertString() method in a PlainDocument sub-class (see the discussion of JTextField in chapter 11 for an example).

PlainDocument uses a BranchElement as its root and has only LeafElements as children. In this case each LeafElement represents a line of text and the root BranchElement represents the whole document text. PlainDocument identifies a BranchElement as "paragraph" and a LeafElement as "content". Note that the notion of a paragraph in PlainDocument is much different than our normal notion of a paragraph. Usually we think of paragraphs as sections of text separated by line breaks. However, PlainDocument considers each section of text ending with a line break as a line of "content" in its never-ending "paragraph". Figure 19.2 and 19.3 show the structure of a sample PlainDocument and illustrate how Elements and their associated Positions can change when document content changes.

In figure 19.2 we see a PlainDocument containing three elements. Two LeafElements represent two lines of text and are children of the root BranchElement. Note that the this root element begins at offset 0, the start offset of the first LeafElement, and ends at 19, the end offset of the last LeafElement. This document would be displayed in a JTextArea as:

This document would now be displayed in a JTextArea as:

JTextArea, JTextField, and JPasswordField use PlainDocument as their model. Only JTextArea allows its document to contain multiple LeafElements. JTextField and its JPasswordField subclass allow only one LeafElement.

DefaultStyledDocument provides significantly more power over the PlainDocument structure described above. This StyledDocument implementation (see 19.1.3) is used for marked up (styled) text. JTextPane uses an instance of DefaultStyledDocument by default (although this may change based on its content type).

DefaultStyledDocument uses and instance of its inner SectionElement class as its root Element, which has only instances of AbstractDocument.BranchElement as children. These BranchElements represent paragraphs, referred to as paragraph Elements, and they contain instances of AbstractDocument.LeafElement as children. These LeafElements represent what are referred to as character ! Elements. Character Elements represent regions of text (possibly multiple lines within a paragraph) that share the same attributes.

We can retrieve the character Element occupying a given offset with the getCharacterElement() method, and we can retrieve the paragraph Element occupying a given offset with the getParagraphElement() method.

We will discuss attributes, AttributeSets, and their usage details soon enough. However, it is important to understand here that AttributeSets assigned to DefaultStyledDocument Elements resolve hierarchically. For instance, a character Element will inherit all attributes assigned to itself, as well as those assigned to the parent paragraph Element. Character Element attributes override those of the same type defined in the parent paragraph Element’s AttributeSet.

Figure 19.4 shows a simple DefaultStyledDocument in a JTextPane with two paragraphs.

Using AbstractDocument’s dump() method to display this document’s Element structure to standard output (see 19.1.4), we get the following:

Note the use of <section>, <paragraph>, and <content> to denote SectionElement, BranchElement, and LeafElement respectively. Also note that the <paragraph> and <content> tags each contain several attributes. The <paragraph> attributes represent paragraph Element attributes and the <content> attributes represent character Element attributes. We will discuss specific attributes in more detail below. Note that the <bidi root> tag specifies a second root Element allowing bidirectional text (this functionality is incomplete as of Java 2 FCS).

We can assign paragraph and character attributes to a region of text with the setParagraphAttributes() and setCharacterAttributes() methods respectively. These methods require a start and end offset, specifying the region to apply the attributes to, as well as an AttributeSet containing the attributes, and a boolean flag specifying whether or not to replace pre-existing attributes with the new attributes.

Regarding the range of text, paragraph attributes will be applied to paragraph Elements that contain at least some portion of the specified range. Character attributes will be applied to all character Elements that intersect that range. If the specified range only partially extends into a character Element, that Element will be split into two, so that only the specified range of text will receive the new attributes (this splitting is handled by an instance of the ElementBuffer inner class).

Regarding the boolean flag, if the flag is true, all pre-existing paragraph Element attributes are removed before the new set is applied. Otherwise, the new set is merged with the old set, and any new attributes overwrite pre-existing attributes. Character attributes work in a similar way, but they do not change paragraph attributes at all--they simply override them.

DefaultStyledDocument also defines the notion of logical paragraph Styles. A logical paragraph Style acts as the resolving parent of a paragraph Element’s AttributeSet. So attributes defined in a paragraph Element’s AttributeSet override those defined in that paragraph’s logical Style. We can change a specific paragraph Element’s logical style with the setLogicalStyle() method. The logical style of each paragraph defaults to StyleContext.DEFAULT_STYLE (which is empty by default).

JTextPane implements getParagraphAttributes(), setParagraphAttributes(), getLogicalStyle(), and setLogicalStyle() methods which communicate directly with its StyledDocument. JTextPane’s paragraph attributes and logical style setXX() methods apply to the paragraph the caret currently resides in if there is no selection. If there is a selection, these methods apply to all paragraphs spanned by! the selected region. JTextPane’s paragraph attributes and logical style getXX() methods apply to the paragraph currently containing the caret.

JTextPane also implements getCharacterAttributes() and setCharacterAttributes() methods. If there is a selection, the setCharacterAttributes() method will act as described above, splitting Elements as needed. If there is no selection, this method will modify JTextPane’s input attributes.

A StyleContext instance (see 19.1.16) is associated with each DefaultStyledDocument. As we mentioned in the beginning of this chapter, the Style interface describes a named mutable AttributeSet, and the StyledDocument interface describes a Document which manages a set of Styles. A DefaultStyledDocument’s StyleContext ins! tance is what performs the actual management, creation, and assignment of that document’s Styles. If a StyleContext is not provided to the DefaultStyledDocument constructor, a default version is created.

JTextPane defines several methods for adding, removing, and retrieving Styles, as well as specific attributes within a given AttributeSet (such as the getFont() and getForeground() methods). Calls to these methods are forwarded to methods of the same signature in JTextPane’s StyledDocument, and, in the case of DefaultStyledDocument, these calls are forwarded to the StyleContext in charge of all the Styles.

DefaultStyledDocument also includes several significant inner classes:

An attribute is simply a key/value pair (as in a Hashtable) that should be recognized by some View implementation available to the text component being used. As we know from our discussion above, each Element in a DefaultStyledDocument has an associated set of attributes which resolves hierarchically. The attributes play a critical role in how that piece of the document will be rendered by a View. For example, one commonly used attribute is FontFamily. The FontFamily attribute key is an Object consisting of the String "family". The FontFamily attribute value is a String representing the name of a font (i.e. "monospaced"). Other examples of attribute keys include "Icon" and "Component," whose values are instances of Icon and Component respectively.

If an attribute is not recognized by a View, the Element associated with that view will not be rendered correctly. Thus, there is a predefined set of attributes that is recognized by the Swing View classes, and these attribute keys should be considered reserved -- in other words, all new attributes should use new keys. These predefined attribute keys are all accessible as static Objects in the StyleConstants class (see 19.1.15).

Sets of attributes are encapsulated in implementations of either the AttributeSet interface, the MutableAttributeSet interface (see 19.1.13), or the Style interface (see 19.1.14). Style extends MutableAttributeSet which, in turn, extends AttributeSet. The AttributeSet interface describes a read-only set of attributes because it does not provide methods for changing, adding, or removing attributes from that set.

The containsAttribute() and containsAttributes() methods are intended for checking whether an AttributeSet contains a given attribute key/value pair, or any number of such pairs. The copyAttributes() method is meant to return a fresh, immutable copy of the AttributeSet it is invoked on. The getAttributeCount() method should return the number of attributes contained in a set, and getAttributeNames() should retrieve an Enumeratio! n of the keys describing each attribute. The isDefined() method is intended for checking whether a given attribute key corresponds to an attribute directly stored in the AttributeSet the method is invoked on (resolving parents are not searched). The isEqual() method is meant to compare two AttributeSets and return whether or not they contain identical attribute key/value pairs. The getResolveParent() method should return a reference to an AttributeSet’s resolving parent, if any, and the getAttribute() me! th! od is intended to return the value of an attribute corresponding to a given key.

The AttributeSet interface also provides four empty static interfaces: CharacterAttribute, ColorAttribute, FontAttribute, ParagraphAttribute. The only reason these interfaces exist is to provide a signature (i.e. information about the class in which it is defined) which is expected of each attribute key. This signature can be used to verify whether an attribute belongs to a certain category (see 19.1.15).

Only one direct implementation of the AttributeSet interface exists within the text package: StyleContext.SmallAttributeSet. A SmallAttributeSet is an array of attribute key/value pairs stored in the alternating pattern: key1, value1, key2, value2, etc. (thus the number of attributes contained in a SmallAttributeSet is actually half the size of its array). An array is used for storage because AttributeSet describes a read-only set of attributes, and using an array is more memory-efficient than dynamically resizable storage such as that provided by a Hasht! able. However, it is less time-efficient to search through an array than a Hashtable. For this reason, SmallAttributeSet is intended to be used only for small sets of attributes. These sets are usually shared between several Elements. Because of the way sharing works (see 19.1.16), the smaller the set of attributes the better candidate that set is for being shared.

The MutableAttributeSet interface extends the AttributeSet interface and declares additional methods intended to allow attribute addition, removal, and resolving parent assignment: addAttribute(), addAttributes(), setResolveParent(), removeAttribute(), and two variations of removeAttributes().

MutableAttributeSet also has two direct implementations within the text package: AbstractDocument.AbstractElement and SimpleAttributeSet. The fact that AbstractElement implements MutableAttributeSet allows such Elements to act as resolving parents to one another. It also reduces object overhead by combining structural information about a region of text with that region’s stylistic attributes.

SimpleAttributeSet uses a Hashtable to store attribute key/value pairs because it must be dynamically resizable. By nature, a Hashtable is less efficient than an array in memory usage, but more efficient in look-up speed. For this reason, SimpleAttributeSets are used for large sets of attributes that are not shared.

The Style interface extends MutableAttributeSet and provides the ability to attach listeners for notification of changes to its set of attributes. Style also adds a String used for name identification. The only direct implementation of the Style interface is provided by StyleContext.NamedStyle. Internally, NamedStyle maintains its own private AttributeSet implementation that contains all its attributes. This AttributeSet can be an instance of StyleContext.SmallAttributeSet or SimpleAttributeSet, and may switch back and forth between these types over the course of its lifetime (this will become clear after our discussion of StyleContext).

The StyleConstants class categorizes predefined attribute keys into members of four static inner classes: CharacterConstants, ColorConstants, FontConstants, and ParagraphConstants. These Objects are all aliased from their outer class, StyleConstants, so they are more easily accessible (aliasing here means providing a reference to an object of an inner class). Also, both ColorConst! ants and FontConstants keys are aliased by CharacterConstants to provide a sensible hierarchy of attribute key organization.

Most keys are self-explanatory in meaning. The StyleConstants API documentation page contains a helpful diagram illustrating the meaning of some of the less self-explanitory attribute keys that apply to paragraphs of styled text. (Each of the keys illustrated in this diagram is an alias of the actual key defined in StyleConstants.ParagraphConstants.)

StyleConstants also defines static methods for assigning and retrieving many predefined attributes in an AttributeSet. For example, to assign a specific font family attribute to an AttributeSet (assuming it is mutable), we can use StyleConstants’ setFontFamily() method.

StyleContext implements the AbstractDocument.AttributeContext interface, and declares a set of methods used to modify or fetch new instances of AttributeSet implementations. AbstractContext was designed with the understanding that the implementor may use more than one type of AttributeSet implementation to store sets of attributes. The decision to use one type over another may be based on any number of factors, and StyleContext takes full advantage of this design.

StyleContext‘s main role is to act as a container for Styles that may be used by one or more DefaultStyledDocuments. It maintains a private NamedStyle instance used to store its Styles and allow access by name. Each of these contained Styles is also an instance of NamedStyle. So, to clarify, StyleContext maintains a NamedStyle instance whose key/value pai! rs are of the form String/NamedStyle.

StyleContext also maintains a subset of these NamedStyle values in a Hashtable. Only those NamedStyle’s whose AttributeSet contains 9 or less attributes are stored in this Hashtable and their AttributeSets are maintained as instances of SmallAttributeSet. Those NamedStyles with an AttributeSet containing 10 or more attributes are not stored in the Hashtable, and their AttributeSets are maintained as instances of SimpleAttributeSet.

This partitioning is managed dynamically by StyleContext, and is the result of combining the AbstractContext design with the use of a compression threshold (a hard-coded int value of 9). Whenever an attribute is added or removed, StyleContext checks the number of attributes in the target AttributeSet. If the resulting set will contain 9 or less attributes it remains, or is converted to, a SmallAttributeSet and is added to the Hashtable if it wasn’t alre! ady there. If the resulting set will contain 10 or more attributes it remains, or is converted to, a SimpleAttributeSet and is removed from the Hashtable if it was already there.

The reason for this partitioning is to support efficient AttributeSet sharing. Most styled documents contain many distinct regions of identically styled text. These regions normally have a small number of attributes associated with them. It is clear that the best thing to do in this situation is to assign the same AttributeSet to each of these regions. And the best AttributeSet implementation to use for this is SmallAttributeSet due to its superior memory efficiency (since look-up speed is a minor issue with a very small number of attributes). Larger sets of attributes are, in general, rare. The best AttributeSet implementation to use for this is SimpleAttributeSet due to its superior look-up capabilities (since memory usage will most likely be a minor issue with a relatively small number of SimpleAttributeSets).

This interface describes how specific regions of text can be marked up with instances of the inner Highlighter.Highlight interface. A Highlight maintains a beginning and end offset, and a reference to an instance of the inner Highlighter.HighlightPainter interface. A HighlightPainter’s only responsibility is to render the background of a specific region of text.

A text component’s UI delegate is responsible for maintaining its Highlighter. For this reason the Highlighter can change when a text component’s look and feel changes. JTextComponent provides methods for working with a text component’s Highlighter so we generally ignore the fact that such methods really get forwarded to the UI delegate.

A Highlighter is intended to maintain an array of Highlighter.Highlight instances, and we are meant to be able to add to this array using the addHighlight() method. This method takes two ints defining the range of text to highlight, as well as a Highlighter.HighlightPainter instance specifying how that Highlight should be rendered. Thus, by defining various HighlightPainters, we can add an arbitrary number of highlighted regions with distinct visual effects.

The range a Highlight encompasses is meant to be modified with the changeHighlight() method, and Highlights can be removed from a Highlighter’s array with the removeAllHighlights() or removeHighlight() methods. The paint() method is meant to manage the rendering of all a Highligher’s Highlights.

We can assign a new Highlighter with JTextComponent’s setHighlighter() method. Similarly, we can retrieve a reference to the existing one with JTextComponent’s getHighlighter() method. Each JTextComponent also maintains a selectionColor property which specifies the color to use in rendering default highlights.

DefaultHighlighter extends the abstract LayeredHighlighter class. LayeredHighlighter implements the Highlighter interface and defines a paintLayeredHighlights() method, which is responsible for managing potentially multiple overlapping Highlights. LayeredHighlighter also declares an inner abstract static class called LayerPainter from which the static ! DefaultHighlighter.DefaultHighlightPainter extends. This implementation paints a solid background, behind the specified region of text, in the current text component selection color.

This interface describes a text component’s cursor. The paint() method is responsible for rendering the caret, and the setBlinkRate()/getBlinkRate() methods are meant to assign/retrieve a specific caret blink interval (normally in milliseconds). The setVisible() and isVisible() methods are intended to hide/show the caret and check for caret visibility, respectively.

The setDot()/getDot() methods are meant to assign/retrieve the offset of the caret within the current document. The getMark() method should return a location in the document where the caret’s mark has been assigned. The moveDot() method is intended to assign a mark position, and move the caret to a new location while highlighting the text between the dot and the mark. The setSelectionVisible()/isSelectionVisible() methods are meant to assign/query the visible state of the highlight specifying the currently selected text.

The setMagicCaretPosition()/getMagicCaretPosition() methods manage a dynamic caret position used when moving the caret up and down between lines with the arrow keys. When moving up and down between lines with an unequal number of characters, the magic position should place the caret as close to the same location within each line as possible. If the magic position is greater than the length of the current line, the caret should be placed at the end of the line. Note that this feature is common in almost all modern text applications, and is implemented for us in the DefaultCaret class.

The Caret interface also declares methods for the registration of ChangeListeners for notification of changes in the caret’s position: addChangeListener(), removeChangeListener().

This class extends java.awt.Rectangle, and represents a concrete implementation of the Caret interface used by all text components by default. It is rendered as a blinking vertical line in the color specified by its associated text component’s caretColor property. DefaultCaret also implements the FocusListener, MouseListener, and MouseMotionListener interfaces.

The only MouseListener methods without empty implementations are mouseClicked() and mousePressed(). If a mouse click occurs with the left mouse button, and the click count is two (i.e. a double-click), mouseClicked() will invoke the Action returned by DefaultEditorKit.selectWordAction() to select the word containing the caret. If the click count is three, mouseClicked() will invoke the Action returned by DefaultEditorKit.selectLineAction() to select the line of text containing the caret. The mousePressed() method sends its MouseEvent parameter to DefaultCaret’s positionCaret() method, which sets the dot property to the document offset corresponding to the mouse press, and clears the magicCaretPosition property. The mousePressed() method also checks to see if the text component is enabled, and if ! it is, its requestFocus() method is invoked.

class WideCaret extends DefaultCaret 
{
  protected int caretWidth = 6;

  protected void setWidth(int w) {
    caretWidth = w;
  }

  // Since DefaultCaret extends Rectangle, it inherits
  // the x, y, width, and height variables which are 
  // used here to allow proper repainting.
  protected synchronized void damage(Rectangle r) {
    if (r != null) {
      x = r.x - width;
      y = r.y;
      width = width;
      height = r.height;
      repaint();
    }
  }

  public void paint(Graphics g) {
    if(isVisible()) {
      try {
        TextUI mapper = getComponent().getUI();
        Rectangle r = mapper.modelToView(
          getComponent(), getComponent().getCaretPosition());
        g.setColor(getComponent().getCaretColor());
        g.fillRect(r.x, r.y, caretWidth, r.height - 1);
      } 
      catch (Exception e) {
        System.err.println("Problem painting cursor");
      }
    }
  }
}

  Hashtable actionTable = new Hashtable
  Action[] actions = myEditorKit.getActions();
  for (int i=0; i < actions.length; i++) {
    String actionName = (String) actions[i].getValue(Action.NAME);
    actionTable.put(actionName, actions[i]);
  }

  Action selectAll = (Action) actionTable.get(DefaultEditorKit.selectAllAction);

/**
 * This is the name of the default keymap that will be shared by all
 * JTextComponent instances unless they have had a different
 * keymap set. 
 */
public static final String DEFAULT_KEYMAP = "default";

/**
 * Default bindings for the default keymap if no other bindings
 * are given.  
 */
static final KeyBinding[] defaultBindings = {
  new KeyBinding(KeyStroke.getKeyStroke(KeyEvent.VK_BACK_SPACE, 0),
    DefaultEditorKit.deletePrevCharAction),
  new KeyBinding(KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, 0),
    DefaultEditorKit.deleteNextCharAction),
  new KeyBinding(KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, 0),
    DefaultEditorKit.forwardAction),
  new KeyBinding(KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, 0),
    DefaultEditorKit.backwardAction)
};

static {
  try {
    keymapTable = new Hashtable(17);
    Keymap binding = addKeymap(DEFAULT_KEYMAP, null);
    binding.setDefaultAction(new
      DefaultEditorKit.DefaultKeyTypedAction());
    EditorKit kit = new DefaultEditorKit();
    loadKeymap(binding, defaultBindings, kit.getActions());
  } catch (Throwable e) {
    e.printStackTrace();
    keymapTable = new Hashtable(17);
  }
}

static class StyledViewFactory implements ViewFactory {
  public View create(Element elem) {
    String kind = elem.getName();
    if (kind != null) {
      if (kind.equals(AbstractDocument.ContentElementName)) {
        return new LabelView(elem);
      } else if (kind.equals(AbstractDocument.ParagraphElementName)) {
          return new ParagraphView(elem);
      } else if (kind.equals(AbstractDocument.SectionElementName)) {
          return new BoxView(elem, View.Y_AXIS);
      } else if (kind.equals(StyleConstants.ComponentElementName)) {
          return new ComponentView(elem);
      } else if (kind.equals(StyleConstants.IconElementName)) {
          return new IconView(elem);
      }
    }
    // default to text display
    return new LabelView(elem);
  }
}

import java.awt.event.*;
import java.text.*;
import java.util.*;
import java.awt.*;
import javax.swing.*;
import javax.swing.border.*;
import javax.swing.text.*;
import javax.swing.event.*;

public class DateTimeEditor extends JPanel
{
   public static final long ONE_SECOND = 1000;
   public static final long ONE_MINUTE = 60*ONE_SECOND;
   public static final long ONE_HOUR = 60*ONE_MINUTE;
   public static final long ONE_DAY = 24*ONE_HOUR;
   public static final long ONE_WEEK = 7*ONE_DAY;
   public final static int TIME = 0;
   public final static int DATE = 1;
   public final static int DATETIME = 2;
   private int m_timeOrDateType;
   private int m_lengthStyle;
   private DateFormat m_format;
   private Calendar m_calendar = Calendar.getInstance();
   private ArrayList m_fieldPositions = new ArrayList();
   private Date m_lastDate = new Date();
   private Caret m_caret;
   private int m_curField = -1;
   private JTextField m_textField;
   private Spinner m_spinner;
   private AbstractAction m_upAction = 
      new UpDownAction(1, "up");
   private AbstractAction m_downAction = 
      new UpDownAction(-1, "down");

   private boolean m_settingDateText = false; // BUG FIX

   private int[] m_fieldTypes =
   {
      DateFormat.ERA_FIELD,
      DateFormat.YEAR_FIELD,
      DateFormat.MONTH_FIELD,
      DateFormat.DATE_FIELD,
      DateFormat.HOUR_OF_DAY1_FIELD,
      DateFormat.HOUR_OF_DAY0_FIELD,
      DateFormat.MINUTE_FIELD,
      DateFormat.SECOND_FIELD,
      DateFormat.MILLISECOND_FIELD,
      DateFormat.DAY_OF_WEEK_FIELD,
      DateFormat.DAY_OF_YEAR_FIELD,
      DateFormat.DAY_OF_WEEK_IN_MONTH_FIELD,
      DateFormat.WEEK_OF_YEAR_FIELD,
      DateFormat.WEEK_OF_MONTH_FIELD,
      DateFormat.AM_PM_FIELD,
      DateFormat.HOUR1_FIELD,
      DateFormat.HOUR0_FIELD
   };

   public DateTimeEditor()
   {
      m_timeOrDateType = DATETIME;
      m_lengthStyle = DateFormat.SHORT;
      init();
   }

   public DateTimeEditor(int timeOrDateType)
   {
      m_timeOrDateType = timeOrDateType;
      m_lengthStyle = DateFormat.FULL;
      init();
   }

   public DateTimeEditor(int timeOrDateType, int lengthStyle)
   {
      m_timeOrDateType = timeOrDateType;
      m_lengthStyle = lengthStyle;
      init();
   }

   private void init()
   {
      setLayout(new BorderLayout());
      m_textField = new JTextField();

      m_textField.setDocument(new DateTimeDocument()); // BUG FIX

      m_spinner = new Spinner();
      m_spinner.getIncrementButton().addActionListener(m_upAction);
      m_spinner.getDecrementButton().addActionListener(m_downAction);
      add(m_textField, "Center");
      add(m_spinner, "East");
      m_caret = m_textField.getCaret();
      m_caret.addChangeListener(new ChangeListener()
      {
        public void stateChanged(ChangeEvent evt)
        { 
          setCurField(); 
        }
      });
      setupKeymap();
      reinit();
   }

   protected class DateTimeDocument extends PlainDocument
   {
      public void insertString(int offset, 
       String str, AttributeSet a) throws BadLocationException 
      {
        if (m_settingDateText)
           super.insertString(offset, str, a);
      }
   } // BUG FIX

   public int getTimeOrDateType() { return m_timeOrDateType; }
   public void setTimeOrDateType(int timeOrDateType)
   {
      m_timeOrDateType = timeOrDateType;
      reinit();
   }

   public int getLengthStyle() { return m_lengthStyle; }
   public void setLengthStyle(int lengthStyle)
   {
      m_lengthStyle = lengthStyle;
      reinit();
   }
   
   public Date getDate() { return (m_lastDate); }
// public void setDate(Date date)
// {
//    m_lastDate = date;
//    m_calendar.setTime(m_lastDate);
//    m_textField.setText(m_format.format(m_lastDate));
//    getFieldPositions();
// }
   
   public void setDate(Date date) {
      m_lastDate = date;
      m_calendar.setTime(m_lastDate);
      m_settingDateText = true;
      m_textField.setText(m_format.format(m_lastDate));
      m_settingDateText = false;
      getFieldPositions();
   } // BUG FIX

   
   private int getFieldBeginIndex(int fieldNum)
   {
      int beginIndex = -1;
      for (Iterator iter = m_fieldPositions.iterator(); 
        iter.hasNext(); )
      {
         FieldPosition fieldPos = (FieldPosition) iter.next();
         if (fieldPos.getField() == fieldNum)
         {
            beginIndex = fieldPos.getBeginIndex();
            break;
         }
      }
      return (beginIndex);
   }
   
   private FieldPosition getFieldPosition(int fieldNum)
   {
      FieldPosition result = null;
      for (Iterator iter = m_fieldPositions.iterator(); 
        iter.hasNext(); )
      {
         FieldPosition fieldPosition = (FieldPosition) iter.next();
         if (fieldPosition.getField() == fieldNum)
         {
            result = fieldPosition;
            break;
         }
      }
      return (result);
   }
   
   private void reinit()
   {
      setupFormat();
      setDate(m_lastDate);
      m_caret.setDot(0);
      setCurField();
      repaint();
   }
   
   protected void setupFormat()
   {
      switch (m_timeOrDateType)
      {
         case TIME:
            m_format = DateFormat.getTimeInstance(m_lengthStyle);
            break;
         case DATE:
            m_format = DateFormat.getDateInstance(m_lengthStyle);
            break;
         case DATETIME:
            m_format = DateFormat.getDateTimeInstance(m_lengthStyle,
              m_lengthStyle);
            break;
      }
   }
   
   protected class UpDownAction extends AbstractAction
   {
      int m_direction; // +1 = up; -1 = down

      public UpDownAction(int direction, String name)
      {
         super(name);
         m_direction = direction;
      }
      
      public void actionPerformed(ActionEvent evt)
      {
         if (!this.isEnabled())
            return;
         boolean dateSet  = true;
         switch (m_curField)
         {
            case DateFormat.AM_PM_FIELD:
               m_lastDate.setTime(m_lastDate.getTime() +
                 (m_direction * 12*ONE_HOUR));
               break;
            case DateFormat.DATE_FIELD:
            case DateFormat.DAY_OF_WEEK_FIELD:
            case DateFormat.DAY_OF_WEEK_IN_MONTH_FIELD:
            case DateFormat.DAY_OF_YEAR_FIELD:
               m_lastDate.setTime(m_lastDate.getTime() +
                 (m_direction * ONE_DAY));
               break;
            case DateFormat.ERA_FIELD:
               dateSet = false;
               break;
            case DateFormat.HOUR0_FIELD:
            case DateFormat.HOUR1_FIELD:
            case DateFormat.HOUR_OF_DAY0_FIELD:
            case DateFormat.HOUR_OF_DAY1_FIELD:
               m_lastDate.setTime(m_lastDate.getTime() +
                 (m_direction * ONE_HOUR));
               break;
            case DateFormat.MILLISECOND_FIELD:
               m_lastDate.setTime(m_lastDate.getTime() + 
                 (m_direction * 1));
               break;
            case DateFormat.MINUTE_FIELD:
               m_lastDate.setTime(m_lastDate.getTime() +
                 (m_direction * ONE_MINUTE));
               break;
            case DateFormat.MONTH_FIELD:
               m_calendar.set(Calendar.MONTH,
                 m_calendar.get(Calendar.MONTH) + m_direction);
               m_lastDate = m_calendar.getTime();
               break;
            case DateFormat.SECOND_FIELD:
               m_lastDate.setTime(m_lastDate.getTime() +
                 (m_direction * ONE_SECOND));
               break;
            case DateFormat.WEEK_OF_MONTH_FIELD:
               m_calendar.set(Calendar.WEEK_OF_MONTH,
                 m_calendar.get(Calendar.WEEK_OF_MONTH) +
                   m_direction);
               m_lastDate = m_calendar.getTime();
               break;
            case DateFormat.WEEK_OF_YEAR_FIELD:
               m_calendar.set(Calendar.WEEK_OF_MONTH,
                 m_calendar.get(Calendar.WEEK_OF_MONTH) +
                   m_direction);
               m_lastDate = m_calendar.getTime();
               break;
            case DateFormat.YEAR_FIELD:
               m_calendar.set(Calendar.YEAR,
                 m_calendar.get(Calendar.YEAR) + m_direction);
               m_lastDate = m_calendar.getTime();
               break;
            default:
               dateSet = false;
         }

         if (dateSet)
         {
           int fieldId = m_curField;
           setDate(m_lastDate);
           FieldPosition fieldPosition = getFieldPosition(fieldId);
           m_caret.setDot(fieldPosition.getBeginIndex());

           m_textField.requestFocus();
           repaint();
         }
      }
   }

   protected class BackwardAction extends TextAction
   {
      BackwardAction(String name) { super(name); }
      
      public void actionPerformed(ActionEvent e)
      {
         JTextComponent target = getTextComponent(e);
         if (target != null)
         {
            int dot = target.getCaretPosition();
            if (dot > 0)
            {
               FieldPosition position = getPrevField(dot);
               if (position != null)
                  target.setCaretPosition(
                     position.getBeginIndex());
               else
               {
                  position = getFirstField();
                  if (position != null)
                     target.setCaretPosition(
                        position.getBeginIndex());
               }
            }
            else
               target.getToolkit().beep();
            target.getCaret().setMagicCaretPosition(null);
         }
      }
   }

   protected class ForwardAction extends TextAction
   {
      ForwardAction(String name) { super(name); }

      public void actionPerformed(ActionEvent e)
      {
         JTextComponent target = getTextComponent(e);
         if (target != null)
         {
            FieldPosition position = getNextField(
               target.getCaretPosition());
            if (position != null)
               target.setCaretPosition(position.getBeginIndex());
            else
            {
               position = getLastField();
               if (position != null)
                  target.setCaretPosition(
                     position.getBeginIndex());
            }
            target.getCaret().setMagicCaretPosition(null);
         }
      }
   }
   
   protected class BeginAction extends TextAction
   {
      BeginAction(String name) { super(name); }

      public void actionPerformed(ActionEvent e)
      {
         JTextComponent target = getTextComponent(e);
         if (target != null)
         {
            FieldPosition position = getFirstField();
            if (position != null)
               target.setCaretPosition(position.getBeginIndex());
         }
      }
   }

   protected class EndAction extends TextAction
   {
      EndAction(String name) { super(name); }

      public void actionPerformed(ActionEvent e)
      {
         JTextComponent target = getTextComponent(e);
         if (target != null)
         {
            FieldPosition position = getLastField();
            if (position != null)
               target.setCaretPosition(position.getBeginIndex());
         }
      }
   }
   
   protected void setupKeymap()
   {
      Keymap keymap = m_textField.addKeymap("DateTimeKeymap", null);
      keymap.addActionForKeyStroke(KeyStroke.getKeyStroke(
         KeyEvent.VK_UP, 0), m_upAction);
      keymap.addActionForKeyStroke(KeyStroke.getKeyStroke(
         KeyEvent.VK_DOWN, 0), m_downAction);
      keymap.addActionForKeyStroke(KeyStroke.getKeyStroke(
         KeyEvent.VK_LEFT, 0), new BackwardAction(DefaultEditorKit.
            backwardAction));
      keymap.addActionForKeyStroke(KeyStroke.getKeyStroke(
         KeyEvent.VK_RIGHT, 0), new ForwardAction(DefaultEditorKit.
            forwardAction));
      keymap.addActionForKeyStroke(KeyStroke.getKeyStroke(
         KeyEvent.VK_HOME, 0), new BeginAction(DefaultEditorKit.
            beginAction));
      keymap.addActionForKeyStroke(KeyStroke.getKeyStroke(
         KeyEvent.VK_END, 0), new EndAction(DefaultEditorKit.
            endAction));
      m_textField.setKeymap(keymap);
   }
   
   private void getFieldPositions()
   {
      m_fieldPositions.clear();
      for (int ctr = 0; ctr < m_fieldTypes.length; ++ ctr)
      {
         int fieldId = m_fieldTypes[ctr];
         FieldPosition fieldPosition = new FieldPosition(fieldId);
         StringBuffer formattedField = new StringBuffer();
         m_format.format(m_lastDate, formattedField, fieldPosition);
         if (fieldPosition.getEndIndex() > 0)
            m_fieldPositions.add(fieldPosition);
      }
      m_fieldPositions.trimToSize();
      Collections.sort(m_fieldPositions,
         new Comparator()
         {
            public int compare(Object o1, Object o2)
            {
               return (((FieldPosition) o1).getBeginIndex() -
                  ((FieldPosition) o2).getBeginIndex());
            }
         }
      );
   }

   private FieldPosition getField(int caretLoc)
   {
      FieldPosition fieldPosition = null;
      for (Iterator iter = m_fieldPositions.iterator(); 
         iter.hasNext(); )
      {
         FieldPosition chkFieldPosition = 
            (FieldPosition) iter.next();
         if ((chkFieldPosition.getBeginIndex() <= caretLoc) &&
             (chkFieldPosition.getEndIndex() > caretLoc))
         {
            fieldPosition = chkFieldPosition;
            break;
         }
      }
      return (fieldPosition);
   }

   private FieldPosition getPrevField(int caretLoc)
   {
      FieldPosition fieldPosition = null;
      for (int ctr = m_fieldPositions.size() - 1; ctr > -1; -- ctr)
      {
         FieldPosition chkFieldPosition =
            (FieldPosition) m_fieldPositions.get(ctr);
         if (chkFieldPosition.getEndIndex() <= caretLoc)
         {
            fieldPosition = chkFieldPosition;
            break;
         }
      }
      return (fieldPosition);
   }

   private FieldPosition getNextField(int caretLoc)
   {
      FieldPosition  fieldPosition = null;
      for (Iterator iter = m_fieldPositions.iterator(); 
         iter.hasNext(); )
      {
         FieldPosition chkFieldPosition = 
            (FieldPosition) iter.next();
         if (chkFieldPosition.getBeginIndex() > caretLoc)
         {
            fieldPosition = chkFieldPosition;
            break;
         }
      }
      return (fieldPosition);
   }

   private FieldPosition getFirstField()
   {
      FieldPosition result = null;
      try { result = ((FieldPosition) m_fieldPositions.get(0)); }
      catch (NoSuchElementException ex) {}
      return (result);
   }

   private FieldPosition getLastField()
   {
      FieldPosition result = null;
      try
      {
         result =
            ((FieldPosition) m_fieldPositions.get(
               m_fieldPositions.size() - 1));
      }
      catch (NoSuchElementException ex) {}
      return (result);
   }
   
   private void setCurField()
   {
      FieldPosition fieldPosition = getField(m_caret.getDot());
      if (fieldPosition != null)
      {
         if (m_caret.getDot() != fieldPosition.getBeginIndex())
            m_caret.setDot(fieldPosition.getBeginIndex());
      }
      else
      {
         fieldPosition = getPrevField(m_caret.getDot());
         if (fieldPosition != null)
            m_caret.setDot(fieldPosition.getBeginIndex());
         else
         {
            fieldPosition = getFirstField();
            if (fieldPosition != null)
               m_caret.setDot(fieldPosition.getBeginIndex());
         }
      }
      
      if (fieldPosition != null)
         m_curField = fieldPosition.getField();
      else
         m_curField = -1;
   }

   public void setEnabled(boolean enable)
   {
      m_textField.setEnabled(enable);
      m_spinner.setEnabled(enable);
   }

   public boolean isEnabled()
   { return (m_textField.isEnabled() && m_spinner.isEnabled()); }
  
   public static void main (String[] args)
   {
      JFrame frame = new JFrame();
      frame.addWindowListener(new WindowAdapter()
      {
         public void windowClosing(WindowEvent evt)
         { System.exit(0); }
      });

      JPanel panel = new JPanel(new BorderLayout());
      panel.setBorder(new EmptyBorder(5, 5, 5, 5));
      frame.setContentPane(panel);
      final DateTimeEditor field =
         new DateTimeEditor(DateTimeEditor.DATETIME, 
            DateFormat.FULL);
      panel.add(field, "North");

      JPanel buttonBox = new JPanel(new GridLayout(2, 2));
      JButton showDateButton = new JButton("Show Date");
      buttonBox.add(showDateButton);

      final JComboBox timeDateChoice = new JComboBox();
      timeDateChoice.addItem("Time");
      timeDateChoice.addItem("Date");
      timeDateChoice.addItem("Date/Time");
      timeDateChoice.setSelectedIndex(2);
      timeDateChoice.addActionListener(new ActionListener()
      {
         public void actionPerformed(ActionEvent evt)
         {
            field.setTimeOrDateType(timeDateChoice.
               getSelectedIndex());
         }
      });
      buttonBox.add(timeDateChoice);

      JButton toggleButton = new JButton("Toggle Enable");
      buttonBox.add(toggleButton);
      showDateButton.addActionListener(new ActionListener()
      { 
         public void actionPerformed(ActionEvent evt)
         { System.out.println(field.getDate()); } 
      });
      toggleButton.addActionListener(new ActionListener()
      { 
         public void actionPerformed(ActionEvent evt)
         { field.setEnabled(!field.isEnabled());} 
      });
      panel.add(buttonBox, "South");

      final JComboBox lengthStyleChoice = new JComboBox();
      lengthStyleChoice.addItem("Full");
      lengthStyleChoice.addItem("Long");
      lengthStyleChoice.addItem("Medium");
      lengthStyleChoice.addItem("Short");
      lengthStyleChoice.addActionListener(new ActionListener()
      {
         public void actionPerformed(ActionEvent evt)
         {
            field.setLengthStyle(lengthStyleChoice.
               getSelectedIndex());
         }
      });
      buttonBox.add(lengthStyleChoice);

      frame.pack();
      Dimension dim = frame.getToolkit().getScreenSize();
      frame.setLocation(dim.width/2 - frame.getWidth()/2,
         dim.height/2 - frame.getHeight()/2);
      frame.show();
   }
}

import java.util.*;
import java.lang.reflect.*;
import java.awt.*;
import javax.swing.*;
import javax.swing.plaf.*;
import javax.swing.plaf.basic.*;

public class Spinner extends JPanel
{
   private int m_orientation = SwingConstants.VERTICAL;
   private BasicArrowButton m_incrementButton;
   private BasicArrowButton m_decrementButton;

   public Spinner() { createComponents(); }

   public Spinner(int orientation)
   {
      m_orientation = orientation;
      createComponents();
   }

   public void setEnabled(boolean enable)
   {
      m_incrementButton.setEnabled(enable);
      m_decrementButton.setEnabled(enable);
   }

   public boolean isEnabled()
   {
      return (m_incrementButton.isEnabled() &&
         m_decrementButton.isEnabled());
   }
   
   protected void createComponents()
   {
      if (m_orientation == SwingConstants.VERTICAL)
      {
         setLayout(new GridLayout(2, 1));
         m_incrementButton = new BasicArrowButton(
            SwingConstants.NORTH);
         m_decrementButton = new BasicArrowButton(
            SwingConstants.SOUTH);
         add(m_incrementButton);
         add(m_decrementButton);
      }
      else if (m_orientation == SwingConstants.HORIZONTAL)
      {
         setLayout(new GridLayout(1, 2));
         m_incrementButton = new BasicArrowButton(
            SwingConstants.EAST);
         m_decrementButton = new BasicArrowButton(
            SwingConstants.WEST);
         add(m_decrementButton);
         add(m_incrementButton);
      }
   }

   public JButton getIncrementButton() { 
      return (m_incrementButton); }
   public JButton getDecrementButton() { 
      return (m_decrementButton); }

   public static void main(String[] args)
   {
      JFrame frame = new JFrame();
      JPanel panel = (JPanel) frame.getContentPane();
      panel.setLayout(new BorderLayout());
      JTextField  field = new JTextField(20);
      Spinner spinner = new Spinner();

      panel.add(field, "Center");
      panel.add(spinner, "East");

      Dimension dim = frame.getToolkit().getScreenSize();
      frame.setLocation(dim.width/2 - frame.getWidth()/2,
         dim.height/2 - frame.getHeight()/2);
      frame.pack();
      frame.show();
   }
}

    public void setDate(Date date) {
      m_lastDate = date;
      m_calendar.setTime(m_lastDate);
      m_settingDateText = true;
      m_textField.setText(m_format.format(m_lastDate));
      m_settingDateText = false;
      getFieldPositions();
    }

    protected class DateTimeDocument extends PlainDocument 
    {
      public void insertString(int offset, String str, AttributeSet a) throws BadLocationException
      {
        if (m_settingDateText)
          super.insertString(offset, str, a);
      }
    }