null.
*/
static JTextComponent componentWithSelection;
/** An implementation of NavigationFilter.FilterBypass which delegates
* to the corresponding methods of the DefaultCaret.
*
* @author Robert Schuster (robertschuster@fsfe.org)
*/
class Bypass extends NavigationFilter.FilterBypass
{
public Caret getCaret()
{
return DefaultCaret.this;
}
public void moveDot(int dot, Bias bias)
{
DefaultCaret.this.moveDotImpl(dot);
}
public void setDot(int dot, Bias bias)
{
DefaultCaret.this.setDotImpl(dot);
}
}
/**
* Controls the blinking of the caret.
*
* @author Roman Kennke (kennke@aicas.com)
* @author Audrius Meskauskas (AudriusA@Bioinformatics.org)
*/
private class BlinkTimerListener implements ActionListener
{
/**
* Forces the next event to be ignored. The next event should be ignored
* if we force the caret to appear. We do not know how long will it take
* to fire the comming event; this may be near immediately. Better to leave
* the caret visible one iteration longer.
*/
boolean ignoreNextEvent;
/**
* Receives notification when the blink timer fires and updates the visible
* state of the caret.
*
* @param event the action event
*/
public void actionPerformed(ActionEvent event)
{
if (ignoreNextEvent)
ignoreNextEvent = false;
else
{
visible = !visible;
repaint();
}
}
}
/**
* Listens for changes in the text component's document and updates the
* caret accordingly.
*
* @author Roman Kennke (kennke@aicas.com)
*/
private class DocumentHandler implements DocumentListener
{
/**
* Receives notification that some text attributes have changed. No action
* is taken here.
*
* @param event the document event
*/
public void changedUpdate(DocumentEvent event)
{
// Nothing to do here.
}
/**
* Receives notification that some text has been inserted from the text
* component. The caret is moved forward accordingly.
*
* @param event the document event
*/
public void insertUpdate(DocumentEvent event)
{
if (policy == ALWAYS_UPDATE ||
(SwingUtilities.isEventDispatchThread() &&
policy == UPDATE_WHEN_ON_EDT))
{
int dot = getDot();
setDot(dot + event.getLength());
}
}
/**
* Receives notification that some text has been removed into the text
* component. The caret is moved backwards accordingly.
*
* @param event the document event
*/
public void removeUpdate(DocumentEvent event)
{
if (policy == ALWAYS_UPDATE
|| (SwingUtilities.isEventDispatchThread()
&& policy == UPDATE_WHEN_ON_EDT))
{
int dot = getDot();
setDot(dot - event.getLength());
}
else if (policy == NEVER_UPDATE
|| (! SwingUtilities.isEventDispatchThread()
&& policy == UPDATE_WHEN_ON_EDT))
{
int docLength = event.getDocument().getLength();
if (getDot() > docLength)
setDot(docLength);
}
}
}
/**
* Listens for property changes on the text document. This is used to add and
* remove our document listener, if the document of the text component has
* changed.
*
* @author Roman Kennke (kennke@aicas.com)
*/
private class PropertyChangeHandler implements PropertyChangeListener
{
/**
* Receives notification when a property has changed on the text component.
* This adds/removes our document listener from the text component's
* document when the document changes.
*
* @param e the property change event
*/
public void propertyChange(PropertyChangeEvent e)
{
String name = e.getPropertyName();
if (name.equals("document"))
{
Document oldDoc = (Document) e.getOldValue();
if (oldDoc != null)
oldDoc.removeDocumentListener(documentListener);
Document newDoc = (Document) e.getNewValue();
if (newDoc != null)
newDoc.addDocumentListener(documentListener);
}
else if (name.equals("editable"))
{
active = (((Boolean) e.getNewValue()).booleanValue()
&& textComponent.isEnabled());
}
else if (name.equals("enabled"))
{
active = (((Boolean) e.getNewValue()).booleanValue()
&& textComponent.isEditable());
}
}
}
/** The serialization UID (compatible with JDK1.5). */
private static final long serialVersionUID = 4325555698756477346L;
/**
* Indicates the Caret position should always be updated after Document
* changes even if the updates are not performed on the Event Dispatching
* thread.
*
* @since 1.5
*/
public static final int ALWAYS_UPDATE = 2;
/**
* Indicates the Caret position should not be changed unless the Document
* length becomes less than the Caret position, in which case the Caret
* is moved to the end of the Document.
*
* @since 1.5
*/
public static final int NEVER_UPDATE = 1;
/**
* Indicates the Caret position should be updated only if Document changes
* are made on the Event Dispatcher thread.
*
* @since 1.5
*/
public static final int UPDATE_WHEN_ON_EDT = 0;
/** Keeps track of the current update policy **/
int policy = UPDATE_WHEN_ON_EDT;
/**
* The ChangeEvent that is fired by {@link #fireStateChanged()}.
*/
protected ChangeEvent changeEvent = new ChangeEvent(this);
/**
* Stores all registered event listeners.
*/
protected EventListenerList listenerList = new EventListenerList();
/**
* Our document listener.
*/
DocumentListener documentListener;
/**
* Our property listener.
*/
PropertyChangeListener propertyChangeListener;
/**
* The text component in which this caret is installed.
*
* (Package private to avoid synthetic accessor method.)
*/
JTextComponent textComponent;
/**
* Indicates if the selection should be visible or not.
*/
private boolean selectionVisible = true;
/**
* The blink rate of this Caret.
*/
private int blinkRate = 500;
/**
* The current dot position.
*/
private int dot = 0;
/**
* The current mark position.
*/
private int mark = 0;
/**
* The current visual caret position.
*/
private Point magicCaretPosition = null;
/**
* Indicates if this Caret is currently visible or not. This is
* package private to avoid an accessor method.
*/
boolean visible = false;
/** Indicates whether the text component where the caret is installed is
* editable and enabled. If either of these properties is false
* the caret is not drawn.
*/
boolean active = true;
/**
* The current highlight entry.
*/
private Object highlightEntry;
private Timer blinkTimer;
private BlinkTimerListener blinkListener;
/**
* A NavigationFilter.FilterBypass instance which
* is provided to the a NavigationFilter to
* unconditionally set or move the caret.
*/
NavigationFilter.FilterBypass bypass;
/**
* Creates a new DefaultCaret instance.
*/
public DefaultCaret()
{
// Nothing to do here.
}
/** Returns the caret's NavigationFilter.FilterBypass instance
* and creates it if it does not yet exist.
*
* @return The caret's NavigationFilter.FilterBypass instance.
*/
private NavigationFilter.FilterBypass getBypass()
{
return (bypass == null) ? bypass = new Bypass() : bypass;
}
/**
* Sets the Caret update policy.
*
* @param policy the new policy. Valid values are:
* ALWAYS_UPDATE: always update the Caret position, even when Document
* updates don't occur on the Event Dispatcher thread.
* NEVER_UPDATE: don't update the Caret position unless the Document
* length becomes less than the Caret position (then update the
* Caret to the end of the Document).
* UPDATE_WHEN_ON_EDT: update the Caret position when the
* Document updates occur on the Event Dispatcher thread. This is the
* default.
*
* @since 1.5
* @throws IllegalArgumentException if policy is not one of the above.
*/
public void setUpdatePolicy (int policy)
{
if (policy != ALWAYS_UPDATE && policy != NEVER_UPDATE
&& policy != UPDATE_WHEN_ON_EDT)
throw new
IllegalArgumentException
("policy must be ALWAYS_UPDATE, NEVER__UPDATE, or UPDATE_WHEN_ON_EDT");
this.policy = policy;
}
/**
* Gets the caret update policy.
*
* @return the caret update policy.
* @since 1.5
*/
public int getUpdatePolicy ()
{
return policy;
}
/**
* Moves the caret position when the mouse is dragged over the text
* component, modifying the selectiony.
*
* When the text component where the caret is installed is disabled, * the selection is not change but you can still scroll the text and * update the caret's location.
* * @param event theMouseEvent describing the drag operation
*/
public void mouseDragged(MouseEvent event)
{
if (event.getButton() == MouseEvent.BUTTON1)
{
if (textComponent.isEnabled())
moveCaret(event);
else
positionCaret(event);
}
}
/**
* Indicates a mouse movement over the text component. Does nothing here.
*
* @param event the MouseEvent describing the mouse operation
*/
public void mouseMoved(MouseEvent event)
{
// Nothing to do here.
}
/**
* When the click is received from Button 1 then the following actions
* are performed here:
*
* MouseEvent describing the click operation
*/
public void mouseClicked(MouseEvent event)
{
// Do not modify selection if component is disabled.
if (!textComponent.isEnabled())
return;
int count = event.getClickCount();
if (event.getButton() == MouseEvent.BUTTON1 && count >= 2)
{
int newDot = getComponent().viewToModel(event.getPoint());
JTextComponent t = getComponent();
try
{
if (count == 3)
{
setDot(Utilities.getRowStart(t, newDot));
moveDot( Utilities.getRowEnd(t, newDot));
}
else
{
int wordStart = Utilities.getWordStart(t, newDot);
// When the mouse points at the offset of the first character
// in a word Utilities().getPreviousWord will not return that
// word but we want to select that. We have to use
// Utilities.getWordStart() to get it.
if (newDot == wordStart)
{
setDot(wordStart);
moveDot(Utilities.getWordEnd(t, wordStart));
}
else
{
int nextWord = Utilities.getNextWord(t, newDot);
int previousWord = Utilities.getPreviousWord(t, newDot);
int previousWordEnd = Utilities.getWordEnd(t, previousWord);
// If the user clicked in the space between two words,
// then select the space.
if (newDot >= previousWordEnd && newDot <= nextWord)
{
setDot(previousWordEnd);
moveDot(nextWord);
}
// Otherwise select the word under the mouse pointer.
else
{
setDot(previousWord);
moveDot(previousWordEnd);
}
}
}
}
catch(BadLocationException ble)
{
// TODO: Swallowing ok here?
}
}
}
/**
* Indicates that the mouse has entered the text component. Nothing is done
* here.
*
* @param event the MouseEvent describing the mouse operation
*/
public void mouseEntered(MouseEvent event)
{
// Nothing to do here.
}
/**
* Indicates that the mouse has exited the text component. Nothing is done
* here.
*
* @param event the MouseEvent describing the mouse operation
*/
public void mouseExited(MouseEvent event)
{
// Nothing to do here.
}
/**
* If the button 1 is pressed, the caret position is updated to the
* position of the mouse click and the text component requests the input
* focus if it is enabled. If the SHIFT key is held down, the caret will
* be moved, which might select the text between the old and new location.
*
* @param event the MouseEvent describing the press operation
*/
public void mousePressed(MouseEvent event)
{
// The implementation assumes that consuming the event makes the AWT event
// mechanism forget about this event instance and not transfer focus.
// By observing how the RI reacts the following behavior has been
// implemented (in regard to text components):
// - a left-click moves the caret
// - a left-click when shift is held down expands the selection
// - a right-click or click with any additional mouse button
// on a text component is ignored
// - a middle-click positions the caret and pastes the clipboard
// contents.
// - a middle-click when shift is held down is ignored
if (SwingUtilities.isLeftMouseButton(event))
{
// Handle the caret.
if (event.isShiftDown() && getDot() != -1)
{
moveCaret(event);
}
else
{
positionCaret(event);
}
// Handle the focus.
if (textComponent != null && textComponent.isEnabled()
&& textComponent.isRequestFocusEnabled())
{
textComponent.requestFocus();
}
// TODO: Handle double click for selecting words.
}
else if(event.getButton() == MouseEvent.BUTTON2)
{
// Special handling for X11-style pasting.
if (! event.isShiftDown())
{
positionCaret(event);
textComponent.paste();
}
}
}
/**
* Indicates that a mouse button has been released on the text component.
* Nothing is done here.
*
* @param event the MouseEvent describing the mouse operation
*/
public void mouseReleased(MouseEvent event)
{
// Nothing to do here.
}
/**
* Sets the caret to visible if the text component is editable.
*
* @param event the FocusEvent
*/
public void focusGained(FocusEvent event)
{
if (textComponent.isEditable())
{
setVisible(true);
updateTimerStatus();
}
}
/**
* Sets the caret to invisible.
*
* @param event the FocusEvent
*/
public void focusLost(FocusEvent event)
{
if (textComponent.isEditable() && event.isTemporary() == false)
{
setVisible(false);
// Stop the blinker, if running.
if (blinkTimer != null && blinkTimer.isRunning())
blinkTimer.stop();
}
}
/**
* Install (if not present) and start the timer, if the caret must blink. The
* caret does not blink if it is invisible, or the component is disabled or
* not editable.
*/
private void updateTimerStatus()
{
if (textComponent.isEnabled() && textComponent.isEditable())
{
if (blinkTimer == null)
initBlinkTimer();
if (!blinkTimer.isRunning())
blinkTimer.start();
}
else
{
if (blinkTimer != null)
blinkTimer.stop();
}
}
/**
* Moves the caret to the position specified in the MouseEvent.
* This will cause a selection if the dot and mark are different.
*
* @param event the MouseEvent from which to fetch the position
*/
protected void moveCaret(MouseEvent event)
{
int newDot = getComponent().viewToModel(event.getPoint());
moveDot(newDot);
}
/**
* Repositions the caret to the position specified in the
* MouseEvent.
*
* @param event the MouseEvent from which to fetch the position
*/
protected void positionCaret(MouseEvent event)
{
int newDot = getComponent().viewToModel(event.getPoint());
setDot(newDot);
}
/**
* Deinstalls this Caret from the specified
* JTextComponent. This removes any listeners that have been
* registered by this Caret.
*
* @param c the text component from which to install this caret
*/
public void deinstall(JTextComponent c)
{
textComponent.removeFocusListener(this);
textComponent.removeMouseListener(this);
textComponent.removeMouseMotionListener(this);
textComponent.getDocument().removeDocumentListener(documentListener);
documentListener = null;
textComponent.removePropertyChangeListener(propertyChangeListener);
propertyChangeListener = null;
textComponent = null;
// Deinstall blink timer if present.
if (blinkTimer != null)
blinkTimer.stop();
blinkTimer = null;
}
/**
* Installs this Caret on the specified
* JTextComponent. This registers a couple of listeners
* on the text component.
*
* @param c the text component on which to install this caret
*/
public void install(JTextComponent c)
{
textComponent = c;
textComponent.addFocusListener(this);
textComponent.addMouseListener(this);
textComponent.addMouseMotionListener(this);
propertyChangeListener = new PropertyChangeHandler();
textComponent.addPropertyChangeListener(propertyChangeListener);
documentListener = new DocumentHandler();
Document doc = textComponent.getDocument();
if (doc != null)
doc.addDocumentListener(documentListener);
active = textComponent.isEditable() && textComponent.isEnabled();
repaint();
}
/**
* Sets the current visual position of this Caret.
*
* @param p the Point to use for the saved location. May be null
* to indicate that there is no visual location
*/
public void setMagicCaretPosition(Point p)
{
magicCaretPosition = p;
}
/**
* Returns the current visual position of this Caret.
*
* @return the current visual position of this Caret
*
* @see #setMagicCaretPosition
*/
public Point getMagicCaretPosition()
{
return magicCaretPosition;
}
/**
* Returns the current position of the mark. The
* mark marks the location in the Document that
* is the end of a selection. If there is no selection, the mark
* is the same as the dot.
*
* @return the current position of the mark
*/
public int getMark()
{
return mark;
}
private void clearHighlight()
{
Highlighter highlighter = textComponent.getHighlighter();
if (highlighter == null)
return;
if (selectionVisible)
{
try
{
if (highlightEntry != null)
highlighter.changeHighlight(highlightEntry, 0, 0);
// Free the global variable which stores the text component with an active
// selection.
if (componentWithSelection == textComponent)
componentWithSelection = null;
}
catch (BadLocationException e)
{
// This should never happen.
throw new InternalError();
}
}
else
{
if (highlightEntry != null)
{
highlighter.removeHighlight(highlightEntry);
highlightEntry = null;
}
}
}
private void handleHighlight()
{
Highlighter highlighter = textComponent.getHighlighter();
if (highlighter == null)
return;
int p0 = Math.min(dot, mark);
int p1 = Math.max(dot, mark);
if (selectionVisible)
{
try
{
if (highlightEntry == null)
highlightEntry = highlighter.addHighlight(p0, p1, getSelectionPainter());
else
highlighter.changeHighlight(highlightEntry, p0, p1);
// If another component currently has a text selection clear that selection
// first.
if (componentWithSelection != null)
if (componentWithSelection != textComponent)
{
Caret c = componentWithSelection.getCaret();
c.setDot(c.getDot());
}
componentWithSelection = textComponent;
}
catch (BadLocationException e)
{
// This should never happen.
throw new InternalError();
}
}
else
{
if (highlightEntry != null)
{
highlighter.removeHighlight(highlightEntry);
highlightEntry = null;
}
}
}
/**
* Sets the visiblity state of the selection.
*
* @param v true if the selection should be visible,
* false otherwise
*/
public void setSelectionVisible(boolean v)
{
if (selectionVisible == v)
return;
selectionVisible = v;
handleHighlight();
repaint();
}
/**
* Returns true if the selection is currently visible,
* false otherwise.
*
* @return true if the selection is currently visible,
* false otherwise
*/
public boolean isSelectionVisible()
{
return selectionVisible;
}
/**
* Causes the Caret to repaint itself.
*/
protected final void repaint()
{
getComponent().repaint(x, y, width, height);
}
/**
* Paints this Caret using the specified Graphics
* context.
*
* @param g the graphics context to use
*/
public void paint(Graphics g)
{
JTextComponent comp = getComponent();
if (comp == null)
return;
// Make sure the dot has a sane position.
dot = Math.min(dot, textComponent.getDocument().getLength());
dot = Math.max(dot, 0);
Rectangle rect = null;
try
{
rect = textComponent.modelToView(dot);
}
catch (BadLocationException e)
{
// Let's ignore that. This shouldn't really occur. But if it
// does (it seems that this happens when the model is mutating),
// it causes no real damage. Uncomment this for debugging.
// e.printStackTrace();
}
if (rect == null)
return;
// Check if paint has possibly been called directly, without a previous
// call to damage(). In this case we need to do some cleanup first.
if ((x != rect.x) || (y != rect.y))
{
repaint(); // Erase previous location of caret.
x = rect.x;
y = rect.y;
width = 1;
height = rect.height;
}
// Now draw the caret on the new position if visible.
if (visible && active)
{
g.setColor(textComponent.getCaretColor());
g.drawLine(rect.x, rect.y, rect.x, rect.y + rect.height - 1);
}
}
/**
* Returns all registered event listeners of the specified type.
*
* @param listenerType the type of listener to return
*
* @return all registered event listeners of the specified type
*/
public Caret changes.
*
* @param listener the listener to register to this caret
*/
public void addChangeListener(ChangeListener listener)
{
listenerList.add(ChangeListener.class, listener);
}
/**
* Removes a {@link ChangeListener} from the list of registered listeners.
*
* @param listener the listener to remove
*/
public void removeChangeListener(ChangeListener listener)
{
listenerList.remove(ChangeListener.class, listener);
}
/**
* Returns all registered {@link ChangeListener}s of this Caret.
*
* @return all registered {@link ChangeListener}s of this Caret
*/
public ChangeListener[] getChangeListeners()
{
return (ChangeListener[]) getListeners(ChangeListener.class);
}
/**
* Notifies all registered {@link ChangeListener}s that the state
* of this Caret has changed.
*/
protected void fireStateChanged()
{
ChangeListener[] listeners = getChangeListeners();
for (int index = 0; index < listeners.length; ++index)
listeners[index].stateChanged(changeEvent);
}
/**
* Returns the JTextComponent on which this Caret
* is installed.
*
* @return the JTextComponent on which this Caret
* is installed
*/
protected final JTextComponent getComponent()
{
return textComponent;
}
/**
* Returns the blink rate of this Caret in milliseconds.
* A value of 0 means that the caret does not blink.
*
* @return the blink rate of this Caret or 0 if
* this caret does not blink
*/
public int getBlinkRate()
{
return blinkRate;
}
/**
* Sets the blink rate of this Caret in milliseconds.
* A value of 0 means that the caret does not blink.
*
* @param rate the new blink rate to set
*/
public void setBlinkRate(int rate)
{
if (blinkTimer != null)
blinkTimer.setDelay(rate);
blinkRate = rate;
}
/**
* Returns the current position of this Caret within the
* Document.
*
* @return the current position of this Caret within the
* Document
*/
public int getDot()
{
return dot;
}
/**
* Moves the dot location without touching the
* mark. This is used when making a selection.
*
* If the underlying text component has a {@link NavigationFilter} * installed the caret will call the corresponding method of that object.
* * @param dot the location where to move the dot * * @see #setDot(int) */ public void moveDot(int dot) { NavigationFilter filter = textComponent.getNavigationFilter(); if (filter != null) filter.moveDot(getBypass(), dot, Bias.Forward); else moveDotImpl(dot); } void moveDotImpl(int dot) { if (dot >= 0) { Document doc = textComponent.getDocument(); if (doc != null) this.dot = Math.min(dot, doc.getLength()); this.dot = Math.max(this.dot, 0); handleHighlight(); appear(); } } /** * Sets the current position of thisCaret within the
* Document. This also sets the mark to the new
* location.
*
* If the underlying text component has a {@link NavigationFilter} * installed the caret will call the corresponding method of that object.
* * @param dot * the new position to be set * @see #moveDot(int) */ public void setDot(int dot) { NavigationFilter filter = textComponent.getNavigationFilter(); if (filter != null) filter.setDot(getBypass(), dot, Bias.Forward); else setDotImpl(dot); } void setDotImpl(int dot) { if (dot >= 0) { Document doc = textComponent.getDocument(); if (doc != null) this.dot = Math.min(dot, doc.getLength()); this.dot = Math.max(this.dot, 0); this.mark = this.dot; clearHighlight(); appear(); } } /** * Show the caret (may be hidden due blinking) and adjust the timer not to * hide it (possibly immediately). * * @author Audrius Meskauskas (AudriusA@Bioinformatics.org) */ void appear() { // All machinery is only required if the carret is blinking. if (blinkListener != null) { blinkListener.ignoreNextEvent = true; // If the caret is visible, erase the current position by repainting // over. if (visible) repaint(); // Draw the caret in the new position. visible = true; Rectangle area = null; int dot = getDot(); try { area = getComponent().modelToView(dot); } catch (BadLocationException e) { // Let's ignore that. This shouldn't really occur. But if it // does (it seems that this happens when the model is mutating), // it causes no real damage. Uncomment this for debugging. // e.printStackTrace(); } if (area != null) { adjustVisibility(area); if (getMagicCaretPosition() == null) setMagicCaretPosition(new Point(area.x, area.y)); damage(area); } } repaint(); } /** * Returnstrue if this Caret is blinking,
* and false if not. The returned value is independent of
* the visiblity of this Caret as returned by {@link #isVisible()}.
*
* @return true if this Caret is blinking,
* and false if not.
* @see #isVisible()
* @since 1.5
*/
public boolean isActive()
{
if (blinkTimer != null)
return blinkTimer.isRunning();
return false;
}
/**
* Returns true if this Caret is currently visible,
* and false if it is not.
*
* @return true if this Caret is currently visible,
* and false if it is not
*/
public boolean isVisible()
{
return visible && active;
}
/**
* Sets the visibility state of the caret. true shows the
* Caret, false hides it.
*
* @param v the visibility to set
*/
public void setVisible(boolean v)
{
if (v != visible)
{
visible = v;
updateTimerStatus();
Rectangle area = null;
int dot = getDot();
try
{
area = getComponent().modelToView(dot);
}
catch (BadLocationException e)
{
AssertionError ae;
ae = new AssertionError("Unexpected bad caret location: " + dot);
ae.initCause(e);
throw ae;
}
if (area != null)
damage(area);
}
}
/**
* Returns the {@link Highlighter.HighlightPainter} that should be used
* to paint the selection.
*
* @return the {@link Highlighter.HighlightPainter} that should be used
* to paint the selection
*/
protected Highlighter.HighlightPainter getSelectionPainter()
{
return DefaultHighlighter.DefaultPainter;
}
/**
* Updates the carets rectangle properties to the specified rectangle and
* repaints the caret.
*
* @param r the rectangle to set as the caret rectangle
*/
protected void damage(Rectangle r)
{
if (r == null)
return;
x = r.x;
y = r.y;
width = 1;
// height is normally set in paint and we leave it untouched. However, we
// must set a valid value here, since otherwise the painting mechanism
// sets a zero clip and never calls paint.
if (height <= 0)
try
{
height = textComponent.modelToView(dot).height;
}
catch (BadLocationException ble)
{
// Should not happen.
throw new InternalError("Caret location not within document range.");
}
repaint();
}
/**
* Adjusts the text component so that the caret is visible. This default
* implementation simply calls
* {@link JComponent#scrollRectToVisible(Rectangle)} on the text component.
* Subclasses may wish to change this.
*/
protected void adjustVisibility(Rectangle rect)
{
getComponent().scrollRectToVisible(rect);
}
/**
* Initializes the blink timer.
*/
private void initBlinkTimer()
{
// Setup the blink timer.
blinkListener = new BlinkTimerListener();
blinkTimer = new Timer(getBlinkRate(), blinkListener);
blinkTimer.setRepeats(true);
}
}