深入解析Java Swing文本组件

需积分: 3 71 浏览量更新于2024-08-02 收藏 475KB PDF 举报

"Java Swing6是Java用于C/S（客户端-服务器）开发的GUI库，主要关注于文本组件的深入探讨。" 在Java Swing中，Swing6版本提供了丰富的组件和功能来构建用户界面，特别是在客户端应用开发中。本章节重点聚焦在文本组件上，这些组件是用户界面中的核心元素，允许用户输入、编辑和查看文本。 19.1 文本包概述文本包（Text package）在Java Swing中扮演着重要角色，它包含了各种用于处理文本的类和接口。虽然深入讨论所有细节超出了本书的范围，但本章旨在提供关于文本组件及其基本组成部分的关键信息，帮助读者理解它们的工作原理。这一部分延续了第11章对文本包主要特性的介绍。 19.1.1 更多关于JTextComponent的信息 `javax.swing.text.JTextComponent` 是一个抽象类，它是所有文本组件的基础。每个JTextComponent都关联有一系列的动作（Actions），这些动作通常绑定到特定的键盘快捷键（见2.13节），并由一个层次结构的、具有解决冲突机制的“ActionMap”管理。这使得开发者可以自定义组件的行为，响应不同的用户输入。例如，JTextComponent包括了常见的文本组件，如JTextField、JTextArea和JEditorPane，它们分别用于单行文本输入、多行文本编辑和富文本显示。这些组件支持基本的文本操作，如插入、删除、复制和粘贴，并且可以与模型（Model）分离，使得数据的处理和显示可以独立进行。 19.1.2 文本组件的特性文本组件不仅限于基本的文本输入，还支持文本格式化、查找替换、文本事件监听等高级功能。例如，通过Document接口，可以动态地改变文本内容，同时触发相应的事件，如DocumentListener可以监听文档的变化。 19.1.3 自定义文本组件本章末尾提供了一个自定义文本字段的例子，用于实现日期和时间的选择。这种自定义组件展示了如何扩展JTextComponent以满足特定需求，比如添加日历选择器或时间选择器，以提供更友好的用户体验。 19.2 词处理器应用程序的开发在接下来的章节中，作者通过构建一个功能齐全的词处理器应用程序，进一步深入讲解文本组件的用法。这个例子将展示如何结合使用这些复杂话题，如文本布局、样式设置、拼写检查等，以创建实际的应用程序。 Java Swing6的文本包提供了强大的工具，用于创建交互式的、功能丰富的用户界面。通过理解和掌握这些组件，开发者能够构建出高效且用户友好的C/S应用。

19.1.13 The MutableAttributeSet interface

abstract interface javax.swing.text.MutableAttributeSet

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.

Note: In the past few sections we have alluded to the importance of efficiency in attribute storage. Efficiency here

refers to both memory usage and speed of attribute location. To summarize the issues: A View uses attributes

to determine how to render its associated Element. These attribute values must be located, by key, within that

Element’s attribute set hierarchy. The faster this location occurs the quicker the view is rendered and the

more responsive the user interface becomes. So look-up speed is a large factor in deciding how to store attribute

key/value pairs. Memory usage is also a large issue. Obtaining efficient look-up speed involves sacrificing

efficient memory usage, and vice-versa. This necessary trade-off is taken into account through the

implementation of the different attribute storage mechanisms described above, and the intelligent management

of when each mechanism is used. We will soon see that the StyleContext class acts as, among other things,

this intelligent manager.

19.1.14 The Style interface

abstract interface javax.swing.text.Style

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).

19.1.15 StyleConstants

class javax.swing.text.StyleConstants

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 ColorConstants and

FontConstants keys are aliased by CharacterConstants to provide a sensible hierarchy of attribute

key organization.

Note: Not all aliased keys use the same name in each class. For instance, FontFamily in StyledConstants is

an alias of Family in StyledConstants.CharacterConstants. However, Family in

StyledConstants.CharacterConstants is an alias of Family (the actual key) in

StyledConstants.FontConstants. Each is a reference to the same key object and it makes no

difference which one we use.

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.

19.1.16 StyleContext

class javax.swing.text.StyleContext

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 pairs 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 already 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).

19.1.17 The Highlighter interface

abstract interface javax.swing.text.Highlighter

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.

19.1.18 DefaultHighlighter

class javax.swing.text.DefaultHighlighter

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.

19.1.19 The Caret interface

abstract interface javax.swing.text.Caret

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().

19.1.20 DefaultCaret

class javax.swing.text.DefaultCaret

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.

The only MouseMotionListener method without an empty implementation is mouseDragged(). This

method simply passes its MouseEvent parameter to DefaultCaret’s moveCaret() method. The

moveCaret() method determines the offset of the caret destination by passing the MouseEvent’s

coordinates to the text component’s viewToModel() method. The moveDot() method is then invoked to

actually move the caret to the determined position (recall that the moveDot() method sets the mark property

and selects the text between the mark position and the new dot position).

Both FocusListener methods are nonempty. The focusGained() method checks whether the text

component is editable, and if it is, the caret is made visible. The focusLost() method simply hides the caret.

These methods are invoked when the text component gains or loses the focus.

We can customize the way a selection’ s highlight appears by overriding DefaultCaret’s

getSelectionPainter() method to return our own Highlighter.HighlightPainter

implementation. We can also customize the appearance of a caret by overriding the paint() method. If we

do reimplement the paint() method, however, we must also override the damage() method. The damage()

method is passed a Rectangle representing the region of the text component to repaint when the caret is

moved.

For instance, the following is a simple DefaultCaret sub-class that renders a wide black caret.

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");

}

19.1.21 The CaretListener interface

abstract interface javax.swing.event.CaretListener

This interface describes a listener that is notified whenever a change occurs in a text component ’s caret

position. It declares one method, caretUpdate(), which takes a CaretEvent as parameter. We can attach

and remove CaretListeners to any JTextComponent with the addCaretListener() and

removeCaretListener() methods respectively.

19.1.22 CaretEvent

class javax.swing.event.CaretEvent

This event simply encapsulates a reference to its source object (normally a text component). CaretEvents

are passed to all attached CaretListeners whenever the associated text component’s caret position changes.

We have implemented a short example in a Swing Connection ‘Tips and Tricks’ article showing how to use a

similar custom caret for designating an overwrite mode. In the same article we also show how to customize a

PlainDocument model to allow ‘insert’ and ‘overwrite’ modes, and how to track caret position with a

CaretListener. See http://java.sun.com/products/jfc/tsc/friends/tips_4/tips_4.html.

剩余114页未读，继续阅读

pratt

粉丝: 1
资源: 8

深入解析Java Swing文本组件

Java Swing实现五子棋游戏开发详解

Java Swing 完全指南

Java Swing图形处理小程序实例教程

javaswing教程 精通javaswing

java_swingProgram.rar_JavaSwing_java swing_swing

java swing漂亮界面 超酷 javaswing教程

java-swing-example.rar_JavaSwing_java swing_图形处理

java swing

Java Swing

java Swing

最新资源

javaswing教程精通javaswing

java swing漂亮界面超酷 javaswing教程