/*
* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package javax.swing;
import java.awt.*;
import java.awt.event.*;
import java.awt.peer.
ComponentPeer;
import java.beans.
Transient;
import javax.swing.plaf.
ViewportUI;
import javax.swing.event.*;
import javax.swing.border.*;
import javax.accessibility.*;
import java.io.
Serializable;
/**
* The "viewport" or "porthole" through which you see the underlying
* information. When you scroll, what moves is the viewport. It is like
* peering through a camera's viewfinder. Moving the viewfinder upwards
* brings new things into view at the top of the picture and loses
* things that were at the bottom.
* <p>
* By default, <code>JViewport</code> is opaque. To change this, use the
* <code>setOpaque</code> method.
* <p>
* <b>NOTE:</b>We have implemented a faster scrolling algorithm that
* does not require a buffer to draw in. The algorithm works as follows:
* <ol><li>The view and parent view and checked to see if they are
* <code>JComponents</code>,
* if they aren't, stop and repaint the whole viewport.
* <li>If the viewport is obscured by an ancestor, stop and repaint the whole
* viewport.
* <li>Compute the region that will become visible, if it is as big as
* the viewport, stop and repaint the whole view region.
* <li>Obtain the ancestor <code>Window</code>'s graphics and
* do a <code>copyArea</code> on the scrolled region.
* <li>Message the view to repaint the newly visible region.
* <li>The next time paint is invoked on the viewport, if the clip region
* is smaller than the viewport size a timer is kicked off to repaint the
* whole region.
* </ol>
* In general this approach is much faster. Compared to the backing store
* approach this avoids the overhead of maintaining an offscreen buffer and
* having to do two <code>copyArea</code>s.
* Compared to the non backing store case this
* approach will greatly reduce the painted region.
* <p>
* This approach can cause slower times than the backing store approach
* when the viewport is obscured by another window, or partially offscreen.
* When another window
* obscures the viewport the copyArea will copy garbage and a
* paint event will be generated by the system to inform us we need to
* paint the newly exposed region. The only way to handle this is to
* repaint the whole viewport, which can cause slower performance than the
* backing store case. In most applications very rarely will the user be
* scrolling while the viewport is obscured by another window or offscreen,
* so this optimization is usually worth the performance hit when obscured.
* <p>
* <strong>Warning:</strong> Swing is not thread safe. For more
* information see <a
* href="package-summary.html#threading">Swing's Threading
* Policy</a>.
* <p>
* <strong>Warning:</strong>
* Serialized objects of this class will not be compatible with
* future Swing releases. The current serialization support is
* appropriate for short term storage or RMI between applications running
* the same version of Swing. As of 1.4, support for long term storage
* of all JavaBeans™
* has been added to the <code>java.beans</code> package.
* Please see {@link java.beans.XMLEncoder}.
*
* @author Hans Muller
* @author Philip Milne
* @see JScrollPane
*/
public class
JViewport extends
JComponent implements
Accessible
{
/**
* @see #getUIClassID
* @see #readObject
*/
private static final
String uiClassID = "ViewportUI";
/** Property used to indicate window blitting should not be done.
*/
static final
Object EnableWindowBlit = "EnableWindowBlit";
/**
* True when the viewport dimensions have been determined.
* The default is false.
*/
protected boolean
isViewSizeSet = false;
/**
* The last <code>viewPosition</code> that we've painted, so we know how
* much of the backing store image is valid.
*/
protected
Point lastPaintPosition = null;
/**
* True when this viewport is maintaining an offscreen image of its
* contents, so that some scrolling can take place using fast "bit-blit"
* operations instead of by accessing the view object to construct the
* display. The default is <code>false</code>.
*
* @deprecated As of Java 2 platform v1.3
* @see #setScrollMode
*/
@
Deprecated
protected boolean
backingStore = false;
/** The view image used for a backing store. */
transient protected
Image backingStoreImage = null;
/**
* The <code>scrollUnderway</code> flag is used for components like
* <code>JList</code>. When the downarrow key is pressed on a
* <code>JList</code> and the selected
* cell is the last in the list, the <code>scrollpane</code> autoscrolls.
* Here, the old selected cell needs repainting and so we need
* a flag to make the viewport do the optimized painting
* only when there is an explicit call to
* <code>setViewPosition(Point)</code>.
* When <code>setBounds</code> is called through other routes,
* the flag is off and the view repaints normally. Another approach
* would be to remove this from the <code>JViewport</code>
* class and have the <code>JList</code> manage this case by using
* <code>setBackingStoreEnabled</code>. The default is
* <code>false</code>.
*/
protected boolean
scrollUnderway = false;
/*
* Listener that is notified each time the view changes size.
*/
private
ComponentListener viewListener = null;
/* Only one <code>ChangeEvent</code> is needed per
* <code>JViewport</code> instance since the
* event's only (read-only) state is the source property. The source
* of events generated here is always "this".
*/
private transient
ChangeEvent changeEvent = null;
/**
* Use <code>graphics.copyArea</code> to implement scrolling.
* This is the fastest for most applications.
*
* @see #setScrollMode
* @since 1.3
*/
public static final int
BLIT_SCROLL_MODE = 1;
/**
* Draws viewport contents into an offscreen image.
* This was previously the default mode for <code>JTable</code>.
* This mode may offer advantages over "blit mode"
* in some cases, but it requires a large chunk of extra RAM.
*
* @see #setScrollMode
* @since 1.3
*/
public static final int
BACKINGSTORE_SCROLL_MODE = 2;
/**
* This mode uses the very simple method of redrawing the entire
* contents of the scrollpane each time it is scrolled.
* This was the default behavior in Swing 1.0 and Swing 1.1.
* Either of the other two options will provide better performance
* in most cases.
*
* @see #setScrollMode
* @since 1.3
*/
public static final int
SIMPLE_SCROLL_MODE = 0;
/**
* @see #setScrollMode
* @since 1.3
*/
private int
scrollMode =
BLIT_SCROLL_MODE;
//
// Window blitting:
//
// As mentioned in the javadoc when using windowBlit a paint event
// will be generated by the system if copyArea copies a non-visible
// portion of the view (in other words, it copies garbage). We are
// not guaranteed to receive the paint event before other mouse events,
// so we can not be sure we haven't already copied garbage a bunch of
// times to different parts of the view. For that reason when a blit
// happens and the Component is obscured (the check for obscurity
// is not supported on all platforms and is checked via ComponentPeer
// methods) the ivar repaintAll is set to true. When paint is received
// if repaintAll is true (we previously did a blit) it is set to
// false, and if the clip region is smaller than the viewport
// waitingForRepaint is set to true and a timer is started. When
// the timer fires if waitingForRepaint is true, repaint is invoked.
// In the mean time, if the view is asked to scroll and waitingForRepaint
// is true, a blit will not happen, instead the non-backing store case
// of scrolling will happen, which will reset waitingForRepaint.
// waitingForRepaint is set to false in paint when the clip rect is
// bigger (or equal) to the size of the viewport.
// A Timer is used instead of just a repaint as it appeared to offer
// better performance.
/**
* This is set to true in <code>setViewPosition</code>
* if doing a window blit and the viewport is obscured.
*/
private transient boolean
repaintAll;
/**
* This is set to true in paint, if <code>repaintAll</code>
* is true and the clip rectangle does not match the bounds.
* If true, and scrolling happens the
* repaint manager is not cleared which then allows for the repaint
* previously invoked to succeed.
*/
private transient boolean
waitingForRepaint;
/**
* Instead of directly invoking repaint, a <code>Timer</code>
* is started and when it fires, repaint is invoked.
*/
private transient
Timer repaintTimer;
/**
* Set to true in paintView when paint is invoked.
*/
private transient boolean
inBlitPaint;
/**
* Whether or not a valid view has been installed.
*/
private boolean
hasHadValidView;
/**
* When view is changed we have to synchronize scrollbar values
* with viewport (see the BasicScrollPaneUI#syncScrollPaneWithViewport method).
* This flag allows to invoke that method while ScrollPaneLayout#layoutContainer
* is running.
*/
private boolean
viewChanged;
/** Creates a <code>JViewport</code>. */
public
JViewport() {
super();
setLayout(
createLayoutManager());
setOpaque(true);
updateUI();
setInheritsPopupMenu(true);
}
/**
* Returns the L&F object that renders this component.
*
* @return a <code>ViewportUI</code> object
* @since 1.3
*/
public
ViewportUI getUI() {
return (
ViewportUI)
ui;
}
/**
* Sets the L&F object that renders this component.
*
* @param ui the <code>ViewportUI</code> L&F object
* @see UIDefaults#getUI
* @beaninfo
* bound: true
* hidden: true
* attribute: visualUpdate true
* description: The UI object that implements the Component's LookAndFeel.
* @since 1.3
*/
public void
setUI(
ViewportUI ui) {
super.setUI(
ui);
}
/**
* Resets the UI property to a value from the current look and feel.
*
* @see JComponent#updateUI
*/
public void
updateUI() {
setUI((
ViewportUI)
UIManager.
getUI(this));
}
/**
* Returns a string that specifies the name of the L&F class
* that renders this component.
*
* @return the string "ViewportUI"
*
* @see JComponent#getUIClassID
* @see UIDefaults#getUI
*/
public
String getUIClassID() {
return
uiClassID;
}
/**
* Sets the <code>JViewport</code>'s one lightweight child,
* which can be <code>null</code>.
* (Since there is only one child which occupies the entire viewport,
* the <code>constraints</code> and <code>index</code>
* arguments are ignored.)
*
* @param child the lightweight <code>child</code> of the viewport
* @param constraints the <code>constraints</code> to be respected
* @param index the index
* @see #setView
*/
protected void
addImpl(
Component child,
Object constraints, int
index) {
setView(
child);
}
/**
* Removes the <code>Viewport</code>s one lightweight child.
*
* @see #setView
*/
public void
remove(
Component child) {
child.
removeComponentListener(
viewListener);
super.remove(
child);
}
/**
* Scrolls the view so that <code>Rectangle</code>
* within the view becomes visible.
* <p>
* This attempts to validate the view before scrolling if the
* view is currently not valid - <code>isValid</code> returns false.
* To avoid excessive validation when the containment hierarchy is
* being created this will not validate if one of the ancestors does not
* have a peer, or there is no validate root ancestor, or one of the
* ancestors is not a <code>Window</code> or <code>Applet</code>.
* <p>
* Note that this method will not scroll outside of the
* valid viewport; for example, if <code>contentRect</code> is larger
* than the viewport, scrolling will be confined to the viewport's
* bounds.
*
* @param contentRect the <code>Rectangle</code> to display
* @see JComponent#isValidateRoot
* @see java.awt.Component#isValid
* @see java.awt.Component#getPeer
*/
public void
scrollRectToVisible(
Rectangle contentRect) {
Component view =
getView();
if (
view == null) {
return;
} else {
if (!
view.
isValid()) {
// If the view is not valid, validate. scrollRectToVisible
// may fail if the view is not valid first, contentRect
// could be bigger than invalid size.
validateView();
}
int
dx,
dy;
dx =
positionAdjustment(
getWidth(),
contentRect.
width,
contentRect.
x);
dy =
positionAdjustment(
getHeight(),
contentRect.
height,
contentRect.
y);
if (
dx != 0 ||
dy != 0) {
Point viewPosition =
getViewPosition();
Dimension viewSize =
view.
getSize();
int
startX =
viewPosition.
x;
int
startY =
viewPosition.
y;
Dimension extent =
getExtentSize();
viewPosition.
x -=
dx;
viewPosition.
y -=
dy;
// Only constrain the location if the view is valid. If the
// the view isn't valid, it typically indicates the view
// isn't visible yet and most likely has a bogus size as will
// we, and therefore we shouldn't constrain the scrolling
if (
view.
isValid()) {
if (
getParent().
getComponentOrientation().
isLeftToRight()) {
if (
viewPosition.
x +
extent.
width >
viewSize.
width) {
viewPosition.
x =
Math.
max(0,
viewSize.
width -
extent.
width);
} else if (
viewPosition.
x < 0) {
viewPosition.
x = 0;
}
} else {
if (
extent.
width >
viewSize.
width) {
viewPosition.
x =
viewSize.
width -
extent.
width;
} else {
viewPosition.
x =
Math.
max(0,
Math.
min(
viewSize.
width -
extent.
width,
viewPosition.
x));
}
}
if (
viewPosition.
y +
extent.
height >
viewSize.
height) {
viewPosition.
y =
Math.
max(0,
viewSize.
height -
extent.
height);
}
else if (
viewPosition.
y < 0) {
viewPosition.
y = 0;
}
}
if (
viewPosition.
x !=
startX ||
viewPosition.
y !=
startY) {
setViewPosition(
viewPosition);
// NOTE: How JViewport currently works with the
// backing store is not foolproof. The sequence of
// events when setViewPosition
// (scrollRectToVisible) is called is to reset the
// views bounds, which causes a repaint on the
// visible region and sets an ivar indicating
// scrolling (scrollUnderway). When
// JViewport.paint is invoked if scrollUnderway is
// true, the backing store is blitted. This fails
// if between the time setViewPosition is invoked
// and paint is received another repaint is queued
// indicating part of the view is invalid. There
// is no way for JViewport to notice another
// repaint has occurred and it ends up blitting
// what is now a dirty region and the repaint is
// never delivered.
// It just so happens JTable encounters this
// behavior by way of scrollRectToVisible, for
// this reason scrollUnderway is set to false
// here, which effectively disables the backing
// store.
scrollUnderway = false;
}
}
}
}
/**
* Ascends the <code>Viewport</code>'s parents stopping when
* a component is found that returns
* <code>true</code> to <code>isValidateRoot</code>.
* If all the <code>Component</code>'s parents are visible,
* <code>validate</code> will then be invoked on it. The
* <code>RepaintManager</code> is then invoked with
* <code>removeInvalidComponent</code>. This
* is the synchronous version of a <code>revalidate</code>.
*/
private void
validateView() {
Component validateRoot =
SwingUtilities.
getValidateRoot(this, false);
if (
validateRoot == null) {
return;
}
// Validate the root.
validateRoot.
validate();
// And let the RepaintManager it does not have to validate from
// validateRoot anymore.
RepaintManager rm =
RepaintManager.
currentManager(this);
if (
rm != null) {
rm.
removeInvalidComponent((
JComponent)
validateRoot);
}
}
/* Used by the scrollRectToVisible method to determine the
* proper direction and amount to move by. The integer variables are named
* width, but this method is applicable to height also. The code assumes that
* parentWidth/childWidth are positive and childAt can be negative.
*/
private int
positionAdjustment(int
parentWidth, int
childWidth, int
childAt) {
// +-----+
// | --- | No Change
// +-----+
if (
childAt >= 0 &&
childWidth +
childAt <=
parentWidth) {
return 0;
}
// +-----+
// --------- No Change
// +-----+
if (
childAt <= 0 &&
childWidth +
childAt >=
parentWidth) {
return 0;
}
// +-----+ +-----+
// | ---- -> | ----|
// +-----+ +-----+
if (
childAt > 0 &&
childWidth <=
parentWidth) {
return -
childAt +
parentWidth -
childWidth;
}
// +-----+ +-----+
// | -------- -> |--------
// +-----+ +-----+
if (
childAt >= 0 &&
childWidth >=
parentWidth) {
return -
childAt;
}
// +-----+ +-----+
// ---- | -> |---- |
// +-----+ +-----+
if (
childAt <= 0 &&
childWidth <=
parentWidth) {
return -
childAt;
}
// +-----+ +-----+
//-------- | -> --------|
// +-----+ +-----+
if (
childAt < 0 &&
childWidth >=
parentWidth) {
return -
childAt +
parentWidth -
childWidth;
}
return 0;
}
/**
* The viewport "scrolls" its child (called the "view") by the
* normal parent/child clipping (typically the view is moved in
* the opposite direction of the scroll). A non-<code>null</code> border,
* or non-zero insets, isn't supported, to prevent the geometry
* of this component from becoming complex enough to inhibit
* subclassing. To create a <code>JViewport</code> with a border,
* add it to a <code>JPanel</code> that has a border.
* <p>Note: If <code>border</code> is non-<code>null</code>, this
* method will throw an exception as borders are not supported on
* a <code>JViewPort</code>.
*
* @param border the <code>Border</code> to set
* @exception IllegalArgumentException this method is not implemented
*/
public final void
setBorder(
Border border) {
if (
border != null) {
throw new
IllegalArgumentException("JViewport.setBorder() not supported");
}
}
/**
* Returns the insets (border) dimensions as (0,0,0,0), since borders
* are not supported on a <code>JViewport</code>.
*
* @return a <code>Rectangle</code> of zero dimension and zero origin
* @see #setBorder
*/
public final
Insets getInsets() {
return new
Insets(0, 0, 0, 0);
}
/**
* Returns an <code>Insets</code> object containing this
* <code>JViewport</code>s inset values. The passed-in
* <code>Insets</code> object will be reinitialized, and
* all existing values within this object are overwritten.
*
* @param insets the <code>Insets</code> object which can be reused
* @return this viewports inset values
* @see #getInsets
* @beaninfo
* expert: true
*/
public final
Insets getInsets(
Insets insets) {
insets.
left =
insets.
top =
insets.
right =
insets.
bottom = 0;
return
insets;
}
private
Graphics getBackingStoreGraphics(
Graphics g) {
Graphics bsg =
backingStoreImage.
getGraphics();
bsg.
setColor(
g.
getColor());
bsg.
setFont(
g.
getFont());
bsg.
setClip(
g.
getClipBounds());
return
bsg;
}
private void
paintViaBackingStore(
Graphics g) {
Graphics bsg =
getBackingStoreGraphics(
g);
try {
super.paint(
bsg);
g.
drawImage(
backingStoreImage, 0, 0, this);
} finally {
bsg.
dispose();
}
}
private void
paintViaBackingStore(
Graphics g,
Rectangle oClip) {
Graphics bsg =
getBackingStoreGraphics(
g);
try {
super.paint(
bsg);
g.
setClip(
oClip);
g.
drawImage(
backingStoreImage, 0, 0, this);
} finally {
bsg.
dispose();
}
}
/**
* The <code>JViewport</code> overrides the default implementation of
* this method (in <code>JComponent</code>) to return false.
* This ensures
* that the drawing machinery will call the <code>Viewport</code>'s
* <code>paint</code>
* implementation rather than messaging the <code>JViewport</code>'s
* children directly.
*
* @return false
*/
public boolean
isOptimizedDrawingEnabled() {
return false;
}
/**
* Returns true if scroll mode is a {@code BACKINGSTORE_SCROLL_MODE} to cause
* painting to originate from {@code JViewport}, or one of its
* ancestors. Otherwise returns {@code false}.
*
* @return true if if scroll mode is a {@code BACKINGSTORE_SCROLL_MODE}.
* @see JComponent#isPaintingOrigin()
*/
protected boolean
isPaintingOrigin() {
return
scrollMode ==
BACKINGSTORE_SCROLL_MODE;
}
/**
* Only used by the paint method below.
*/
private
Point getViewLocation() {
Component view =
getView();
if (
view != null) {
return
view.
getLocation();
}
else {
return new
Point(0,0);
}
}
/**
* Depending on whether the <code>backingStore</code> is enabled,
* either paint the image through the backing store or paint
* just the recently exposed part, using the backing store
* to "blit" the remainder.
* <blockquote>
* The term "blit" is the pronounced version of the PDP-10
* BLT (BLock Transfer) instruction, which copied a block of
* bits. (In case you were curious.)
* </blockquote>
*
* @param g the <code>Graphics</code> context within which to paint
*/
public void
paint(
Graphics g)
{
int
width =
getWidth();
int
height =
getHeight();
if ((
width <= 0) || (
height <= 0)) {
return;
}
if (
inBlitPaint) {
// We invoked paint as part of copyArea cleanup, let it through.
super.paint(
g);
return;
}
if (
repaintAll) {
repaintAll = false;
Rectangle clipB =
g.
getClipBounds();
if (
clipB.
width <
getWidth() ||
clipB.
height <
getHeight()) {
waitingForRepaint = true;
if (
repaintTimer == null) {
repaintTimer =
createRepaintTimer();
}
repaintTimer.
stop();
repaintTimer.
start();
// We really don't need to paint, a future repaint will
// take care of it, but if we don't we get an ugly flicker.
}
else {
if (
repaintTimer != null) {
repaintTimer.
stop();
}
waitingForRepaint = false;
}
}
else if (
waitingForRepaint) {
// Need a complete repaint before resetting waitingForRepaint
Rectangle clipB =
g.
getClipBounds();
if (
clipB.
width >=
getWidth() &&
clipB.
height >=
getHeight()) {
waitingForRepaint = false;
repaintTimer.
stop();
}
}
if (!
backingStore ||
isBlitting() ||
getView() == null) {
super.paint(
g);
lastPaintPosition =
getViewLocation();
return;
}
// If the view is smaller than the viewport and we are not opaque
// (that is, we won't paint our background), we should set the
// clip. Otherwise, as the bounds of the view vary, we will
// blit garbage into the exposed areas.
Rectangle viewBounds =
getView().
getBounds();
if (!
isOpaque()) {
g.
clipRect(0, 0,
viewBounds.
width,
viewBounds.
height);
}
if (
backingStoreImage == null) {
// Backing store is enabled but this is the first call to paint.
// Create the backing store, paint it and then copy to g.
// The backing store image will be created with the size of
// the viewport. We must make sure the clip region is the
// same size, otherwise when scrolling the backing image
// the region outside of the clipped region will not be painted,
// and result in empty areas.
backingStoreImage =
createImage(
width,
height);
Rectangle clip =
g.
getClipBounds();
if (
clip.
width !=
width ||
clip.
height !=
height) {
if (!
isOpaque()) {
g.
setClip(0, 0,
Math.
min(
viewBounds.
width,
width),
Math.
min(
viewBounds.
height,
height));
}
else {
g.
setClip(0, 0,
width,
height);
}
paintViaBackingStore(
g,
clip);
}
else {
paintViaBackingStore(
g);
}
}
else {
if (!
scrollUnderway ||
lastPaintPosition.
equals(
getViewLocation())) {
// No scrolling happened: repaint required area via backing store.
paintViaBackingStore(
g);
} else {
// The image was scrolled. Manipulate the backing store and flush it to g.
Point blitFrom = new
Point();
Point blitTo = new
Point();
Dimension blitSize = new
Dimension();
Rectangle blitPaint = new
Rectangle();
Point newLocation =
getViewLocation();
int
dx =
newLocation.
x -
lastPaintPosition.
x;
int
dy =
newLocation.
y -
lastPaintPosition.
y;
boolean
canBlit =
computeBlit(
dx,
dy,
blitFrom,
blitTo,
blitSize,
blitPaint);
if (!
canBlit) {
// The image was either moved diagonally or
// moved by more than the image size: paint normally.
paintViaBackingStore(
g);
} else {
int
bdx =
blitTo.
x -
blitFrom.
x;
int
bdy =
blitTo.
y -
blitFrom.
y;
// Move the relevant part of the backing store.
Rectangle clip =
g.
getClipBounds();
// We don't want to inherit the clip region when copying
// bits, if it is inherited it will result in not moving
// all of the image resulting in garbage appearing on
// the screen.
g.
setClip(0, 0,
width,
height);
Graphics bsg =
getBackingStoreGraphics(
g);
try {
bsg.
copyArea(
blitFrom.
x,
blitFrom.
y,
blitSize.
width,
blitSize.
height,
bdx,
bdy);
g.
setClip(
clip.
x,
clip.
y,
clip.
width,
clip.
height);
// Paint the rest of the view; the part that has just been exposed.
Rectangle r =
viewBounds.
intersection(
blitPaint);
bsg.
setClip(
r);
super.paint(
bsg);
// Copy whole of the backing store to g.
g.
drawImage(
backingStoreImage, 0, 0, this);
} finally {
bsg.
dispose();
}
}
}
}
lastPaintPosition =
getViewLocation();
scrollUnderway = false;
}
/**
* Sets the bounds of this viewport. If the viewport's width
* or height has changed, fire a <code>StateChanged</code> event.
*
* @param x left edge of the origin
* @param y top edge of the origin
* @param w width in pixels
* @param h height in pixels
*
* @see JComponent#reshape(int, int, int, int)
*/
public void
reshape(int
x, int
y, int
w, int
h) {
boolean
sizeChanged = (
getWidth() !=
w) || (
getHeight() !=
h);
if (
sizeChanged) {
backingStoreImage = null;
}
super.reshape(
x,
y,
w,
h);
if (
sizeChanged ||
viewChanged) {
viewChanged = false;
fireStateChanged();
}
}
/**
* Used to control the method of scrolling the viewport contents.
* You may want to change this mode to get maximum performance for your
* use case.
*
* @param mode one of the following values:
* <ul>
* <li> JViewport.BLIT_SCROLL_MODE
* <li> JViewport.BACKINGSTORE_SCROLL_MODE
* <li> JViewport.SIMPLE_SCROLL_MODE
* </ul>
*
* @see #BLIT_SCROLL_MODE
* @see #BACKINGSTORE_SCROLL_MODE
* @see #SIMPLE_SCROLL_MODE
*
* @beaninfo
* bound: false
* description: Method of moving contents for incremental scrolls.
* enum: BLIT_SCROLL_MODE JViewport.BLIT_SCROLL_MODE
* BACKINGSTORE_SCROLL_MODE JViewport.BACKINGSTORE_SCROLL_MODE
* SIMPLE_SCROLL_MODE JViewport.SIMPLE_SCROLL_MODE
*
* @since 1.3
*/
public void
setScrollMode(int
mode) {
scrollMode =
mode;
backingStore =
mode ==
BACKINGSTORE_SCROLL_MODE;
}
/**
* Returns the current scrolling mode.
*
* @return the <code>scrollMode</code> property
* @see #setScrollMode
* @since 1.3
*/
public int
getScrollMode() {
return
scrollMode;
}
/**
* Returns <code>true</code> if this viewport is maintaining
* an offscreen image of its contents.
*
* @return <code>true</code> if <code>scrollMode</code> is
* <code>BACKINGSTORE_SCROLL_MODE</code>
*
* @deprecated As of Java 2 platform v1.3, replaced by
* <code>getScrollMode()</code>.
*/
@
Deprecated
public boolean
isBackingStoreEnabled() {
return
scrollMode ==
BACKINGSTORE_SCROLL_MODE;
}
/**
* If true if this viewport will maintain an offscreen
* image of its contents. The image is used to reduce the cost
* of small one dimensional changes to the <code>viewPosition</code>.
* Rather than repainting the entire viewport we use
* <code>Graphics.copyArea</code> to effect some of the scroll.
*
* @param enabled if true, maintain an offscreen backing store
*
* @deprecated As of Java 2 platform v1.3, replaced by
* <code>setScrollMode()</code>.
*/
@
Deprecated
public void
setBackingStoreEnabled(boolean
enabled) {
if (
enabled) {
setScrollMode(
BACKINGSTORE_SCROLL_MODE);
} else {
setScrollMode(
BLIT_SCROLL_MODE);
}
}
private boolean
isBlitting() {
Component view =
getView();
return (
scrollMode ==
BLIT_SCROLL_MODE) &&
(
view instanceof
JComponent) &&
view.
isOpaque();
}
/**
* Returns the <code>JViewport</code>'s one child or <code>null</code>.
*
* @return the viewports child, or <code>null</code> if none exists
*
* @see #setView
*/
public
Component getView() {
return (
getComponentCount() > 0) ?
getComponent(0) : null;
}
/**
* Sets the <code>JViewport</code>'s one lightweight child
* (<code>view</code>), which can be <code>null</code>.
*
* @param view the viewport's new lightweight child
*
* @see #getView
*/
public void
setView(
Component view) {
/* Remove the viewport's existing children, if any.
* Note that removeAll() isn't used here because it
* doesn't call remove() (which JViewport overrides).
*/
int
n =
getComponentCount();
for(int
i =
n - 1;
i >= 0;
i--) {
remove(
getComponent(
i));
}
isViewSizeSet = false;
if (
view != null) {
super.addImpl(
view, null, -1);
viewListener =
createViewListener();
view.
addComponentListener(
viewListener);
}
if (
hasHadValidView) {
// Only fire a change if a view has been installed.
fireStateChanged();
}
else if (
view != null) {
hasHadValidView = true;
}
viewChanged = true;
revalidate();
repaint();
}
/**
* If the view's size hasn't been explicitly set, return the
* preferred size, otherwise return the view's current size.
* If there is no view, return 0,0.
*
* @return a <code>Dimension</code> object specifying the size of the view
*/
public
Dimension getViewSize() {
Component view =
getView();
if (
view == null) {
return new
Dimension(0,0);
}
else if (
isViewSizeSet) {
return
view.
getSize();
}
else {
return
view.
getPreferredSize();
}
}
/**
* Sets the size of the view. A state changed event will be fired.
*
* @param newSize a <code>Dimension</code> object specifying the new
* size of the view
*/
public void
setViewSize(
Dimension newSize) {
Component view =
getView();
if (
view != null) {
Dimension oldSize =
view.
getSize();
if (!
newSize.
equals(
oldSize)) {
// scrollUnderway will be true if this is invoked as the
// result of a validate and setViewPosition was previously
// invoked.
scrollUnderway = false;
view.
setSize(
newSize);
isViewSizeSet = true;
fireStateChanged();
}
}
}
/**
* Returns the view coordinates that appear in the upper left
* hand corner of the viewport, or 0,0 if there's no view.
*
* @return a <code>Point</code> object giving the upper left coordinates
*/
public
Point getViewPosition() {
Component view =
getView();
if (
view != null) {
Point p =
view.
getLocation();
p.
x = -
p.
x;
p.
y = -
p.
y;
return
p;
}
else {
return new
Point(0,0);
}
}
/**
* Sets the view coordinates that appear in the upper left
* hand corner of the viewport, does nothing if there's no view.
*
* @param p a <code>Point</code> object giving the upper left coordinates
*/
public void
setViewPosition(
Point p)
{
Component view =
getView();
if (
view == null) {
return;
}
int
oldX,
oldY,
x =
p.
x,
y =
p.
y;
/* Collect the old x,y values for the views location
* and do the song and dance to avoid allocating
* a Rectangle object if we don't have to.
*/
if (
view instanceof
JComponent) {
JComponent c = (
JComponent)
view;
oldX =
c.
getX();
oldY =
c.
getY();
}
else {
Rectangle r =
view.
getBounds();
oldX =
r.
x;
oldY =
r.
y;
}
/* The view scrolls in the opposite direction to mouse
* movement.
*/
int
newX = -
x;
int
newY = -
y;
if ((
oldX !=
newX) || (
oldY !=
newY)) {
if (!
waitingForRepaint &&
isBlitting() &&
canUseWindowBlitter()) {
RepaintManager rm =
RepaintManager.
currentManager(this);
// The cast to JComponent will work, if view is not
// a JComponent, isBlitting will return false.
JComponent jview = (
JComponent)
view;
Rectangle dirty =
rm.
getDirtyRegion(
jview);
if (
dirty == null || !
dirty.
contains(
jview.
getVisibleRect())) {
rm.
beginPaint();
try {
Graphics g =
JComponent.
safelyGetGraphics(this);
flushViewDirtyRegion(
g,
dirty);
view.
setLocation(
newX,
newY);
Rectangle r = new
Rectangle(
0, 0,
getWidth(),
Math.
min(
getHeight(),
jview.
getHeight()));
g.
setClip(
r);
// Repaint the complete component if the blit succeeded
// and needsRepaintAfterBlit returns true.
repaintAll = (
windowBlitPaint(
g) &&
needsRepaintAfterBlit());
g.
dispose();
rm.
notifyRepaintPerformed(this,
r.
x,
r.
y,
r.
width,
r.
height);
rm.
markCompletelyClean((
JComponent)
getParent());
rm.
markCompletelyClean(this);
rm.
markCompletelyClean(
jview);
} finally {
rm.
endPaint();
}
}
else {
// The visible region is dirty, no point in doing copyArea
view.
setLocation(
newX,
newY);
repaintAll = false;
}
}
else {
scrollUnderway = true;
// This calls setBounds(), and then repaint().
view.
setLocation(
newX,
newY);
repaintAll = false;
}
// we must validate the hierarchy to not break the hw/lw mixing
revalidate();
fireStateChanged();
}
}
/**
* Returns a rectangle whose origin is <code>getViewPosition</code>
* and size is <code>getExtentSize</code>.
* This is the visible part of the view, in view coordinates.
*
* @return a <code>Rectangle</code> giving the visible part of
* the view using view coordinates.
*/
public
Rectangle getViewRect() {
return new
Rectangle(
getViewPosition(),
getExtentSize());
}
/**
* Computes the parameters for a blit where the backing store image
* currently contains <code>oldLoc</code> in the upper left hand corner
* and we're scrolling to <code>newLoc</code>.
* The parameters are modified
* to return the values required for the blit.
*
* @param dx the horizontal delta
* @param dy the vertical delta
* @param blitFrom the <code>Point</code> we're blitting from
* @param blitTo the <code>Point</code> we're blitting to
* @param blitSize the <code>Dimension</code> of the area to blit
* @param blitPaint the area to blit
* @return true if the parameters are modified and we're ready to blit;
* false otherwise
*/
protected boolean
computeBlit(
int
dx,
int
dy,
Point blitFrom,
Point blitTo,
Dimension blitSize,
Rectangle blitPaint)
{
int
dxAbs =
Math.
abs(
dx);
int
dyAbs =
Math.
abs(
dy);
Dimension extentSize =
getExtentSize();
if ((
dx == 0) && (
dy != 0) && (
dyAbs <
extentSize.
height)) {
if (
dy < 0) {
blitFrom.
y = -
dy;
blitTo.
y = 0;
blitPaint.
y =
extentSize.
height +
dy;
}
else {
blitFrom.
y = 0;
blitTo.
y =
dy;
blitPaint.
y = 0;
}
blitPaint.
x =
blitFrom.
x =
blitTo.
x = 0;
blitSize.
width =
extentSize.
width;
blitSize.
height =
extentSize.
height -
dyAbs;
blitPaint.
width =
extentSize.
width;
blitPaint.
height =
dyAbs;
return true;
}
else if ((
dy == 0) && (
dx != 0) && (
dxAbs <
extentSize.
width)) {
if (
dx < 0) {
blitFrom.
x = -
dx;
blitTo.
x = 0;
blitPaint.
x =
extentSize.
width +
dx;
}
else {
blitFrom.
x = 0;
blitTo.
x =
dx;
blitPaint.
x = 0;
}
blitPaint.
y =
blitFrom.
y =
blitTo.
y = 0;
blitSize.
width =
extentSize.
width -
dxAbs;
blitSize.
height =
extentSize.
height;
blitPaint.
width =
dxAbs;
blitPaint.
height =
extentSize.
height;
return true;
}
else {
return false;
}
}
/**
* Returns the size of the visible part of the view in view coordinates.
*
* @return a <code>Dimension</code> object giving the size of the view
*/
@
Transient
public
Dimension getExtentSize() {
return
getSize();
}
/**
* Converts a size in pixel coordinates to view coordinates.
* Subclasses of viewport that support "logical coordinates"
* will override this method.
*
* @param size a <code>Dimension</code> object using pixel coordinates
* @return a <code>Dimension</code> object converted to view coordinates
*/
public
Dimension toViewCoordinates(
Dimension size) {
return new
Dimension(
size);
}
/**
* Converts a point in pixel coordinates to view coordinates.
* Subclasses of viewport that support "logical coordinates"
* will override this method.
*
* @param p a <code>Point</code> object using pixel coordinates
* @return a <code>Point</code> object converted to view coordinates
*/
public
Point toViewCoordinates(
Point p) {
return new
Point(
p);
}
/**
* Sets the size of the visible part of the view using view coordinates.
*
* @param newExtent a <code>Dimension</code> object specifying
* the size of the view
*/
public void
setExtentSize(
Dimension newExtent) {
Dimension oldExtent =
getExtentSize();
if (!
newExtent.
equals(
oldExtent)) {
setSize(
newExtent);
fireStateChanged();
}
}
/**
* A listener for the view.
* <p>
* <strong>Warning:</strong>
* Serialized objects of this class will not be compatible with
* future Swing releases. The current serialization support is
* appropriate for short term storage or RMI between applications running
* the same version of Swing. As of 1.4, support for long term storage
* of all JavaBeans™
* has been added to the <code>java.beans</code> package.
* Please see {@link java.beans.XMLEncoder}.
*/
protected class
ViewListener extends
ComponentAdapter implements
Serializable
{
public void
componentResized(
ComponentEvent e) {
fireStateChanged();
revalidate();
}
}
/**
* Creates a listener for the view.
* @return a <code>ViewListener</code>
*/
protected
ViewListener createViewListener() {
return new
ViewListener();
}
/**
* Subclassers can override this to install a different
* layout manager (or <code>null</code>) in the constructor. Returns
* the <code>LayoutManager</code> to install on the <code>JViewport</code>.
*
* @return a <code>LayoutManager</code>
*/
protected
LayoutManager createLayoutManager() {
return
ViewportLayout.
SHARED_INSTANCE;
}
/**
* Adds a <code>ChangeListener</code> to the list that is
* notified each time the view's
* size, position, or the viewport's extent size has changed.
*
* @param l the <code>ChangeListener</code> to add
* @see #removeChangeListener
* @see #setViewPosition
* @see #setViewSize
* @see #setExtentSize
*/
public void
addChangeListener(
ChangeListener l) {
listenerList.
add(
ChangeListener.class,
l);
}
/**
* Removes a <code>ChangeListener</code> from the list that's notified each
* time the views size, position, or the viewports extent size
* has changed.
*
* @param l the <code>ChangeListener</code> to remove
* @see #addChangeListener
*/
public void
removeChangeListener(
ChangeListener l) {
listenerList.
remove(
ChangeListener.class,
l);
}
/**
* Returns an array of all the <code>ChangeListener</code>s added
* to this JViewport with addChangeListener().
*
* @return all of the <code>ChangeListener</code>s added or an empty
* array if no listeners have been added
* @since 1.4
*/
public
ChangeListener[]
getChangeListeners() {
return
listenerList.
getListeners(
ChangeListener.class);
}
/**
* Notifies all <code>ChangeListeners</code> when the views
* size, position, or the viewports extent size has changed.
*
* @see #addChangeListener
* @see #removeChangeListener
* @see EventListenerList
*/
protected void
fireStateChanged()
{
Object[]
listeners =
listenerList.
getListenerList();
for (int
i =
listeners.length - 2;
i >= 0;
i -= 2) {
if (
listeners[
i] ==
ChangeListener.class) {
if (
changeEvent == null) {
changeEvent = new
ChangeEvent(this);
}
((
ChangeListener)
listeners[
i + 1]).
stateChanged(
changeEvent);
}
}
}
/**
* Always repaint in the parents coordinate system to make sure
* only one paint is performed by the <code>RepaintManager</code>.
*
* @param tm maximum time in milliseconds before update
* @param x the <code>x</code> coordinate (pixels over from left)
* @param y the <code>y</code> coordinate (pixels down from top)
* @param w the width
* @param h the height
* @see java.awt.Component#update(java.awt.Graphics)
*/
public void
repaint(long
tm, int
x, int
y, int
w, int
h) {
Container parent =
getParent();
if(
parent != null)
parent.
repaint(
tm,
x+
getX(),
y+
getY(),
w,
h);
else
super.repaint(
tm,
x,
y,
w,
h);
}
/**
* Returns a string representation of this <code>JViewport</code>.
* This method
* is intended to be used only for debugging purposes, and the
* content and format of the returned string may vary between
* implementations. The returned string may be empty but may not
* be <code>null</code>.
*
* @return a string representation of this <code>JViewport</code>
*/
protected
String paramString() {
String isViewSizeSetString = (
isViewSizeSet ?
"true" : "false");
String lastPaintPositionString = (
lastPaintPosition != null ?
lastPaintPosition.
toString() : "");
String scrollUnderwayString = (
scrollUnderway ?
"true" : "false");
return super.paramString() +
",isViewSizeSet=" +
isViewSizeSetString +
",lastPaintPosition=" +
lastPaintPositionString +
",scrollUnderway=" +
scrollUnderwayString;
}
//
// Following is used when doBlit is true.
//
/**
* Notifies listeners of a property change. This is subclassed to update
* the <code>windowBlit</code> property.
* (The <code>putClientProperty</code> property is final).
*
* @param propertyName a string containing the property name
* @param oldValue the old value of the property
* @param newValue the new value of the property
*/
protected void
firePropertyChange(
String propertyName,
Object oldValue,
Object newValue) {
super.firePropertyChange(
propertyName,
oldValue,
newValue);
if (
propertyName.
equals(
EnableWindowBlit)) {
if (
newValue != null) {
setScrollMode(
BLIT_SCROLL_MODE);
} else {
setScrollMode(
SIMPLE_SCROLL_MODE);
}
}
}
/**
* Returns true if the component needs to be completely repainted after
* a blit and a paint is received.
*/
private boolean
needsRepaintAfterBlit() {
// Find the first heavy weight ancestor. isObscured and
// canDetermineObscurity are only appropriate for heavy weights.
Component heavyParent =
getParent();
while (
heavyParent != null &&
heavyParent.
isLightweight()) {
heavyParent =
heavyParent.
getParent();
}
if (
heavyParent != null) {
ComponentPeer peer =
heavyParent.
getPeer();
if (
peer != null &&
peer.
canDetermineObscurity() &&
!
peer.
isObscured()) {
// The peer says we aren't obscured, therefore we can assume
// that we won't later be messaged to paint a portion that
// we tried to blit that wasn't valid.
// It is certainly possible that when we blited we were
// obscured, and by the time this is invoked we aren't, but the
// chances of that happening are pretty slim.
return false;
}
}
return true;
}
private
Timer createRepaintTimer() {
Timer timer = new
Timer(300, new
ActionListener() {
public void
actionPerformed(
ActionEvent ae) {
// waitingForRepaint will be false if a paint came down
// with the complete clip rect, in which case we don't
// have to cause a repaint.
if (
waitingForRepaint) {
repaint();
}
}
});
timer.
setRepeats(false);
return
timer;
}
/**
* If the repaint manager has a dirty region for the view, the view is
* asked to paint.
*
* @param g the <code>Graphics</code> context within which to paint
*/
private void
flushViewDirtyRegion(
Graphics g,
Rectangle dirty) {
JComponent view = (
JComponent)
getView();
if(
dirty != null &&
dirty.
width > 0 &&
dirty.
height > 0) {
dirty.
x +=
view.
getX();
dirty.
y +=
view.
getY();
Rectangle clip =
g.
getClipBounds();
if (
clip == null) {
// Only happens in 1.2
g.
setClip(0, 0,
getWidth(),
getHeight());
}
g.
clipRect(
dirty.
x,
dirty.
y,
dirty.
width,
dirty.
height);
clip =
g.
getClipBounds();
// Only paint the dirty region if it is visible.
if (
clip.
width > 0 &&
clip.
height > 0) {
paintView(
g);
}
}
}
/**
* Used when blitting.
*
* @param g the <code>Graphics</code> context within which to paint
* @return true if blitting succeeded; otherwise false
*/
private boolean
windowBlitPaint(
Graphics g) {
int
width =
getWidth();
int
height =
getHeight();
if ((
width == 0) || (
height == 0)) {
return false;
}
boolean
retValue;
RepaintManager rm =
RepaintManager.
currentManager(this);
JComponent view = (
JComponent)
getView();
if (
lastPaintPosition == null ||
lastPaintPosition.
equals(
getViewLocation())) {
paintView(
g);
retValue = false;
} else {
// The image was scrolled. Manipulate the backing store and flush
// it to g.
Point blitFrom = new
Point();
Point blitTo = new
Point();
Dimension blitSize = new
Dimension();
Rectangle blitPaint = new
Rectangle();
Point newLocation =
getViewLocation();
int
dx =
newLocation.
x -
lastPaintPosition.
x;
int
dy =
newLocation.
y -
lastPaintPosition.
y;
boolean
canBlit =
computeBlit(
dx,
dy,
blitFrom,
blitTo,
blitSize,
blitPaint);
if (!
canBlit) {
paintView(
g);
retValue = false;
} else {
// Prepare the rest of the view; the part that has just been
// exposed.
Rectangle r =
view.
getBounds().
intersection(
blitPaint);
r.
x -=
view.
getX();
r.
y -=
view.
getY();
blitDoubleBuffered(
view,
g,
r.
x,
r.
y,
r.
width,
r.
height,
blitFrom.
x,
blitFrom.
y,
blitTo.
x,
blitTo.
y,
blitSize.
width,
blitSize.
height);
retValue = true;
}
}
lastPaintPosition =
getViewLocation();
return
retValue;
}
//
// NOTE: the code below uses paintForceDoubleBuffered for historical
// reasons. If we're going to allow a blit we've already accounted for
// everything that paintImmediately and _paintImmediately does, for that
// reason we call into paintForceDoubleBuffered to diregard whether or
// not setDoubleBuffered(true) was invoked on the view.
//
private void
blitDoubleBuffered(
JComponent view,
Graphics g,
int
clipX, int
clipY, int
clipW, int
clipH,
int
blitFromX, int
blitFromY, int
blitToX, int
blitToY,
int
blitW, int
blitH) {
// NOTE:
// blitFrom/blitTo are in JViewport coordinates system
// not the views coordinate space.
// clip* are in the views coordinate space.
RepaintManager rm =
RepaintManager.
currentManager(this);
int
bdx =
blitToX -
blitFromX;
int
bdy =
blitToY -
blitFromY;
Composite oldComposite = null;
// Shift the scrolled region
if (
g instanceof
Graphics2D) {
Graphics2D g2d = (
Graphics2D)
g;
oldComposite =
g2d.
getComposite();
g2d.
setComposite(
AlphaComposite.
Src);
}
rm.
copyArea(this,
g,
blitFromX,
blitFromY,
blitW,
blitH,
bdx,
bdy,
false);
if (
oldComposite != null) {
((
Graphics2D)
g).
setComposite(
oldComposite);
}
// Paint the newly exposed region.
int
x =
view.
getX();
int
y =
view.
getY();
g.
translate(
x,
y);
g.
setClip(
clipX,
clipY,
clipW,
clipH);
view.
paintForceDoubleBuffered(
g);
g.
translate(-
x, -
y);
}
/**
* Called to paint the view, usually when <code>blitPaint</code>
* can not blit.
*
* @param g the <code>Graphics</code> context within which to paint
*/
private void
paintView(
Graphics g) {
Rectangle clip =
g.
getClipBounds();
JComponent view = (
JComponent)
getView();
if (
view.
getWidth() >=
getWidth()) {
// Graphics is relative to JViewport, need to map to view's
// coordinates space.
int
x =
view.
getX();
int
y =
view.
getY();
g.
translate(
x,
y);
g.
setClip(
clip.
x -
x,
clip.
y -
y,
clip.
width,
clip.
height);
view.
paintForceDoubleBuffered(
g);
g.
translate(-
x, -
y);
g.
setClip(
clip.
x,
clip.
y,
clip.
width,
clip.
height);
}
else {
// To avoid any problems that may result from the viewport being
// bigger than the view we start painting from the viewport.
try {
inBlitPaint = true;
paintForceDoubleBuffered(
g);
} finally {
inBlitPaint = false;
}
}
}
/**
* Returns true if the viewport is not obscured by one of its ancestors,
* or its ancestors children and if the viewport is showing. Blitting
* when the view isn't showing will work,
* or rather <code>copyArea</code> will work,
* but will not produce the expected behavior.
*/
private boolean
canUseWindowBlitter() {
if (!
isShowing() || (!(
getParent() instanceof
JComponent) &&
!(
getView() instanceof
JComponent))) {
return false;
}
if (
isPainting()) {
// We're in the process of painting, don't blit. If we were
// to blit we would draw on top of what we're already drawing,
// so bail.
return false;
}
Rectangle dirtyRegion =
RepaintManager.
currentManager(this).
getDirtyRegion((
JComponent)
getParent());
if (
dirtyRegion != null &&
dirtyRegion.
width > 0 &&
dirtyRegion.
height > 0) {
// Part of the scrollpane needs to be repainted too, don't blit.
return false;
}
Rectangle clip = new
Rectangle(0,0,
getWidth(),
getHeight());
Rectangle oldClip = new
Rectangle();
Rectangle tmp2 = null;
Container parent;
Component lastParent = null;
int
x,
y,
w,
h;
for(
parent = this;
parent != null &&
isLightweightComponent(
parent);
parent =
parent.
getParent()) {
x =
parent.
getX();
y =
parent.
getY();
w =
parent.
getWidth();
h =
parent.
getHeight();
oldClip.
setBounds(
clip);
SwingUtilities.
computeIntersection(0, 0,
w,
h,
clip);
if(!
clip.
equals(
oldClip))
return false;
if(
lastParent != null &&
parent instanceof
JComponent &&
!((
JComponent)
parent).
isOptimizedDrawingEnabled()) {
Component comps[] =
parent.
getComponents();
int
index = 0;
for(int
i =
comps.length - 1 ;
i >= 0;
i--) {
if(
comps[
i] ==
lastParent) {
index =
i - 1;
break;
}
}
while(
index >= 0) {
tmp2 =
comps[
index].
getBounds(
tmp2);
if(
tmp2.
intersects(
clip))
return false;
index--;
}
}
clip.
x +=
x;
clip.
y +=
y;
lastParent =
parent;
}
if (
parent == null) {
// No Window parent.
return false;
}
return true;
}
/////////////////
// Accessibility support
////////////////
/**
* Gets the AccessibleContext associated with this JViewport.
* For viewports, the AccessibleContext takes the form of an
* AccessibleJViewport.
* A new AccessibleJViewport instance is created if necessary.
*
* @return an AccessibleJViewport that serves as the
* AccessibleContext of this JViewport
*/
public
AccessibleContext getAccessibleContext() {
if (
accessibleContext == null) {
accessibleContext = new
AccessibleJViewport();
}
return
accessibleContext;
}
/**
* This class implements accessibility support for the
* <code>JViewport</code> class. It provides an implementation of the
* Java Accessibility API appropriate to viewport user-interface elements.
* <p>
* <strong>Warning:</strong>
* Serialized objects of this class will not be compatible with
* future Swing releases. The current serialization support is
* appropriate for short term storage or RMI between applications running
* the same version of Swing. As of 1.4, support for long term storage
* of all JavaBeans™
* has been added to the <code>java.beans</code> package.
* Please see {@link java.beans.XMLEncoder}.
*/
protected class
AccessibleJViewport extends
AccessibleJComponent {
/**
* Get the role of this object.
*
* @return an instance of AccessibleRole describing the role of
* the object
*/
public
AccessibleRole getAccessibleRole() {
return
AccessibleRole.
VIEWPORT;
}
} // inner class AccessibleJViewport
}