/*
 * @(#)JViewport.java	1.64 01/11/29
 *
 * Copyright 2002 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

package javax.swing;

import javax.swing.event.*;
import javax.swing.border.*;
import javax.accessibility.*;

import java.applet.Applet;
import java.awt.Component;
import java.awt.Container;
import java.awt.LayoutManager;
import java.awt.Dimension;
import java.awt.Rectangle;
import java.awt.Point;
import java.awt.Insets;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Window;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ComponentListener;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;

import java.io.Serializable;


/**
 * The "viewport" or "porthole" through which you see the underlying
 * information. When you scroll, what moves is the viewport. Its 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><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 JComponents,
 * 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 Windows graphics and do a copyArea 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 copyAreas. 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>To turn this behavior on, put the client property
 * "EnableWindowBlit" (a method will added to enable/disable this in the
 * future).
 * <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.  A future release of Swing will provide support for
 * long term persistence.
 *
 * @version 1.64 11/29/01
 * @author Hans Muller
 * @author Philip Milne
 * @see JScrollPane
 */
public class JViewport extends JComponent implements Accessible
{
    /** Property used to indicate window blitting should not be done.
     */
    static final Object EnableWindowBlit = "EnableWindowBlit";

    /** True when the viewport dimensions have been determined. */
    protected boolean isViewSizeSet = false;

    /**
     * The last viewPosition 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.
     */
    protected boolean backingStore = false;
    /** The view image used for a backing store. */
    transient protected Image backingStoreImage = null;

    /**
     * The scrollUnderway flag is used for components like JList.
     * When the downarrow key is pressed on a JList and the selected
     * cell is the last in the list, the scrollpane autoscrolls.
     * Here, the old selected cell needs repainting and so we need
     * a flag to make the viewport do the optimised painting
     * only when there is an explicit call to setViewPosition(Point).
     * When setBounds() is called through other routes,
     * the flag is off and the view repaints normally.
     * Another approach would be to remove this from the Viewport
     * class and have the JList manage this case by using
     * setBackingStoreEnabled().
     */
    protected boolean scrollUnderway = false;

    /*
     * Listener that's notified each time the view changes size.
     */
    private ComponentListener viewListener = null;

    /* Only one ChangeEvent is needed per JViewport 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;

    /**
     * Whether or not to use the Window's Graphics to blit. This is only
     * used if the client property "EnableWindowBlit" is set
     * (the existance of this property indicates it should be enabled,
     * therefore the value does not matter).
     */
    private transient boolean windowBlit;

    //
    // 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 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 setViewPosition if doing a window blit.
     */
    private transient boolean repaintAll;

    /**
     * This is set to true in paint, if repaintAll is true and the clip
     * rect 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 Timer is started and when
     * it fires, repaint is invoked.
     */
    private transient Timer repaintTimer;

    /** Create a JViewport */
    public JViewport() {
        super();
        setLayout(createLayoutManager());
    }

    /**
     * Sets the Viewport's one lightweight child, which can be null.
     * (Since there is only one child which occupies the entire viewport,
     * the constraints and index arguments are ignored.)
     *
     * @param child       the Component ______________
     * @param constraints the Object ______________
     * @param index       the int ______________
     * @see #setView
     */
    protected void addImpl(Component child, Object constraints, int index) {
      setView(child);
    }


    /**
     * Removes the Viewport's one lightweight child.
     *
     * @see #setView
     */
    public void remove(Component child) {
        child.removeComponentListener(viewListener);
        super.remove(child);
    }


    /**
     * Overridden to scroll the view so that Rectangle within the
     * view becomes visible.
     *
     * @param contentRect the Rectangle to display
     */
    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 = 0, dy = 0;
            Rectangle bounds = getBounds();

            dx = positionAdjustment(bounds.width, contentRect.width, contentRect.x);
            dy = positionAdjustment(bounds.height, contentRect.height, contentRect.y);

            if (dx != 0 || dy != 0) {
                Point viewPosition = getViewPosition();
                setViewPosition(new Point(viewPosition.x - dx, viewPosition.y - dy));
		// 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 occured 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;
            }
        }
    }

    /**
     * This will ascend the receivers parents stopping when a component that
     * found that returns true to isValidateRoot. If all that Components 
     * parents are visible, validate will then be invoked on it. The
     * RepaintManager is then invoked with removeInvalidComponent. This
     * is the synchronous version of a revalidate.
     */
    private void validateView() {
        Component validateRoot = null;

	/* Find the first JComponent ancestor of this component whose
	 * isValidateRoot() method returns true.  
	 */
        for(Component c = this; c != null; c = c.getParent()) {
	    if ((c instanceof CellRendererPane) || (c.getPeer() == null)) {
		return;
	    }
	    if ((c instanceof JComponent) &&
		(((JComponent)c).isValidateRoot())) {
		validateRoot = c;
		break;
	    }
	}

	// If no validateRoot, nothing to validate from.
	if (validateRoot == null) {
	    return;
	}

	// Make sure all ancestors are visible.
	Component root = null;
	
	for(Component c = validateRoot; c != null; c = c.getParent()) {
	    if (!c.isVisible() || (c.getPeer() == null)) {
		return;
	    }
	    if ((c instanceof Window) || (c instanceof Applet)) {
		root = c;
		break;
	    }
	}

	// Make sure there is a Window ancestor.
	if (root == 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);
	}
    }

     /*  This method is used by the scrollToRect 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" it's child (called the "view") by the
     * normal parent/child clipping (typically the view is moved in
     * the opposite direction of the scroll).  A non-null 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 JViewport with a border, add it to a
     * JPanel that has a border.
     *
     * @param border the Border to set
     */
    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 JViewport.
     *
     * @return new Insets(0, 0, 0, 0)
     * @see #setBorder
     */
    public final Insets getInsets() {
        return new Insets(0, 0, 0, 0);
    }

    /**
     * Returns an Insets object containing this JViewport's inset
     * values.  The passed-in Insets object will be reinitialized, and
     * all existing values within this object are overwritten.
     *
     * @param insets the Insets object which can be reused.
     * @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);
        super.paint(bsg);
        g.drawImage(backingStoreImage, 0, 0, this);
    }

    private void paintViaBackingStore(Graphics g, Rectangle oClip) {
        Graphics bsg = getBackingStoreGraphics(g);
        super.paint(bsg);
	g.setClip(oClip);
        g.drawImage(backingStoreImage, 0, 0, this);
    }

    /**
     * The JViewport overrides the default implementation of
     * this method (in JComponent) to return false. This ensures
     * that the drawing machinery will call the Viewport's paint()
     * implementation rather than messaging the JViewport's
     * children directly.
     *
     * @return false
     */
    public boolean isOptimizedDrawingEnabled() {
        return false;
    }


    /**
     * 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 backingStore 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 Graphics context within which to paint
     */
    public void paint(Graphics g)
    {
        int width = getWidth();
        int height = getHeight();

        if ((width <= 0) || (height <= 0)) {
            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 || windowBlit) {
            super.paint(g);
            lastPaintPosition = getViewLocation();
            return;
        }

        // If the view is smaller than the viewport, 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();
        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) {
		g.setClip(0, 0, Math.min(viewBounds.width, width),
			  Math.min(viewBounds.height, 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);
                    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);
                }
            }
        }
        lastPaintPosition = getViewLocation();
        scrollUnderway = false;
    }


    /**
     * Sets the bounds of this viewport.  If the viewports width
     * or height has changed, fire a StateChanged 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) {
	    fireStateChanged();
	}
    }


    /**
     * Returns true if this viewport is maintaining an offscreen
     * image of its contents.
     */
    public boolean isBackingStoreEnabled() {
        return backingStore;
    }


    /**
     * 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 viewPosition.
     * Rather than repainting the entire viewport we use
     * Graphics.copyArea() to effect some of the scroll.
     */
    public void setBackingStoreEnabled(boolean x) {
        backingStore = x;
    }


    /**
     * Returns the Viewport's one child or null.
     *
     * @see #setView
     */
    public Component getView() {
        return (getComponentCount() > 0) ? getComponent(0) : null;
    }

    /**
     * Sets the Viewport's one lightweight child (<code>view</code>),
     * which can be null.
     *
     * @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(i);
        }

        isViewSizeSet = false;

        if (view != null) {
            super.addImpl(view, null, -1);
            viewListener = createViewListener();
            view.addComponentListener(viewListener);
        }

	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 Dimension 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 view coordinates that appear in the upper left
     * hand corner of the viewport, and the size of the view.
     *
     * @param newSize a Dimension object specifying the size and
     *        location of the new view coordinates, or null if there
     *        is no 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, 0,0 if there's no view.
     *
     * @return a Point 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 Point 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 && windowBlit && canUseWindowBlitter()) {
		Graphics g = getGraphics();
		flushViewDirtyRegion(g);
		// This calls setBounds(), and then repaint().
                view.setLocation(newX, newY);
		g.clipRect(0,0,getWidth(),getHeight());
		// Forces a repaint of the whole component on the next
		// call to paint.
		repaintAll = windowBlitPaint(g);
		g.dispose();
		RepaintManager rm = RepaintManager.currentManager(this);
		rm.markCompletelyClean((JComponent)getParent());
		rm.markCompletelyClean(this);
		rm.markCompletelyClean((JComponent)view);
	    }
	    else {
		scrollUnderway = true;
		// This calls setBounds(), and then repaint().
		view.setLocation(newX, newY);
	    }
	    fireStateChanged();
	}
    }


    /**
     * Return a rectangle whose origin is getViewPosition and size is
     * getExtentSize(). This is the visible part of the view, in view
     * coordinates.
     *
     * @return a Rectangle 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 oldLoc in the upper left hand corner
     * and we're scrolling to newLoc.  The parameters are modified
     * to return the values required for the blit.
     */
    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.y = 0;
            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 Dimension object giving the size of the view
     */
    public Dimension getExtentSize() {
        return getSize();
    }


    /**
     * Convert a size in pixel coordinates to view coordinates.
     * Subclasses of viewport that support "logical coordinates"
     * will override this method.
     *
     * @param size  a Dimension object using pixel coordinates
     * @return a Dimension object converted to view coordinates
     */
    public Dimension toViewCoordinates(Dimension size) {
        return new Dimension(size);
    }

    /**
     * Convert a point in pixel coordinates to view coordinates.
     * Subclasses of viewport that support "logical coordinates"
     * will override this method.
     *
     * @param p  a Point object using pixel coordinates
     * @return a Point object converted to view coordinates
     */
    public Point toViewCoordinates(Point p) {
        return new Point(p);
    }


    /**
     * Set the size of the visible part of the view using view coordinates.
     *
     * @param newExtent  a Dimension 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.  A future release of Swing will provide support for
     * long term persistence.
     */
    protected class ViewListener extends ComponentAdapter implements Serializable
    {
        public void componentResized(ComponentEvent e) {
            fireStateChanged();
        }
    }

    /**
     * Create a listener for the view.
     * @return a ViewListener
     */
    protected ViewListener createViewListener() {
        return new ViewListener();
    }


    /**
     * Subclassers can override this to install a different
     * layout manager (or null) in the constructor.  Returns
     * a new JViewportLayout object.
     *
     * @return a LayoutManager
     */
    protected LayoutManager createLayoutManager() {
        return new ViewportLayout();
    }


    /**
     * Add a ChangeListener to the list that's notified each time the view's
     * size, position, or the viewport's extent size has changed.
     *
     * @param l the ChangeListener to add
     * @see #removeChangeListener
     * @see #setViewPosition
     * @see #setViewSize
     * @see #setExtentSize
     */
    public void addChangeListener(ChangeListener l) {
        listenerList.add(ChangeListener.class, l);
    }

    /**
     * Remove a ChangeListener from the list that's notified each
     * time the views size, position, or the viewports extent size
     * has changed.
     *
     * @param l the ChangeListener to remove
     * @see #addChangeListener
     */
    public void removeChangeListener(ChangeListener l) {
        listenerList.remove(ChangeListener.class, l);
    }


    /*
     * Notify all ChangeListeners 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);
            }
        }
    }

    /**
     * We always repaint in our parent coordinate system to make sure
     * only one paint is performed by the RepaintManager.
     *
     * @param     tm   maximum time in milliseconds before update
     * @param     x    the <i>x</i> coordinate (pixels over from left)
     * @param     y    the <i>y</i> coordinate (pixels down from top)
     * @param     width    the width
     * @param     height   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 JViewport. 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 JViewport.
     */
    protected String paramString() {
        String isViewSizeSetString = (isViewSizeSet ?
				      "true" : "false");
        String lastPaintPositionString = (lastPaintPosition != null ?
					  lastPaintPosition.toString() : "");
        String backingStoreString = (backingStore ?
                                    "true" : "false");
        String backingStoreImageString = (backingStoreImage != null ?
					  backingStoreImage.toString() : "");
        String scrollUnderwayString = (scrollUnderway ?
				       "true" : "false");

        return super.paramString() +
        ",backingStore=" + backingStoreString +
        ",backingStoreImage=" + backingStoreImageString +
        ",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> ivar (putClientProperty is final).
     */
    protected void firePropertyChange(String propertyName, Object oldValue,
				      Object newValue) {
	super.firePropertyChange(propertyName, oldValue, newValue);
	if (propertyName.equals(EnableWindowBlit)) {
	    windowBlit = (newValue != null);
	}
    }

    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.
     */
    private void flushViewDirtyRegion(Graphics g) {
	RepaintManager rm = RepaintManager.currentManager(this);
	JComponent view = (JComponent) getView();
	Rectangle dirty;

	dirty = rm.getDirtyRegion((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);
	    paintView(g);
	}		
    }

    /**
     * Used when blitting.
     * @return true if blitting succeeded.
     */
    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 {
		boolean isDBE = rm.isDoubleBufferingEnabled();
		int bdx = blitTo.x - blitFrom.x;
		int bdy = blitTo.y - blitFrom.y;

		// 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();
		Image off = rm.getOffscreenBuffer(this,getWidth(),getHeight());
		Graphics og = off.getGraphics();
		og.translate(-r.x,-r.y);
		og.setClip(r.x,r.y,r.width,r.height);
		rm.setDoubleBufferingEnabled(false);
		view.paint(og);
		rm.setDoubleBufferingEnabled(isDBE);

		// Move the relevant part of the backing store.
		blitWindowGraphics(blitFrom.x, blitFrom.y, blitSize.width,
				   blitSize.height, bdx, bdy);
				
		r.x += view.getX();
		r.y += view.getY();
		g.setClip(r.x,r.y,r.width,r.height);
		g.drawImage(off,r.x,r.y,null);
		og.dispose();
		retValue = true;
	    }
	}
	lastPaintPosition = getViewLocation();
	return retValue;
    }

    /**
     * Called to paint the view, usually when blitPaint can not blit.
     */
    private void paintView(Graphics g) {
	Rectangle r = g.getClipBounds();
	RepaintManager rm = RepaintManager.currentManager(this);
	boolean dblbEnable = rm.isDoubleBufferingEnabled();
	JComponent view = (JComponent) getView();
	r.x -= view.getX();
	r.y -= view.getY();
	Image off = rm.getOffscreenBuffer(this,r.width,r.height);
	Graphics og = off.getGraphics();
	og.translate(-r.x,-r.y);
	og.setClip(r.x,r.y,r.width,r.height);
	rm.setDoubleBufferingEnabled(false);
	view.paint(og);
	if(dblbEnable)
	    rm.setDoubleBufferingEnabled(true);
	g.drawImage(off,r.x + view.getX(),r.y + view.getY(),null);
	og.dispose();
    }

    /**
     * Blits the parent windows graphics from the given region offset
     * to <code>ox</code>, <code>oy</code>.
     */
    private void blitWindowGraphics(int x, int y, int w, int h, int ox,
				    int oy) {
	Container parent;
	for(parent = getParent() ; !(parent instanceof Window) ;
	    parent = parent.getParent());
	Graphics wg = parent.getGraphics();
	Rectangle r = new Rectangle(x,y,w,h);
	r = SwingUtilities.convertRectangle(this, r, parent);
	wg.copyArea(r.x,r.y,r.width,r.height, ox, oy);
    }

    /**
     * Returns true if the receiver is not obscured by one of its ancestors,
     * or its ancestors children.
     */
    private boolean canUseWindowBlitter() {
	if (!(getParent() instanceof JComponent) &&
	    !(getView() instanceof JComponent)) {
	    return false;
	}
	Rectangle clip = new Rectangle(0,0,getWidth(),getHeight());
	Rectangle oldClip = new Rectangle();
	Rectangle tmp2;
	Rectangle b;
	Container parent;
	Component lastParent = null;
		
	for(parent = this ; !(parent instanceof java.awt.Window) &&
		parent != null; parent = parent.getParent()) {
	    if(parent instanceof JComponent) {
		b = ((JComponent)parent)._bounds;
	    } else {
		b = parent.getBounds();
	    }

	    oldClip.setBounds(clip);
	    SwingUtilities.computeIntersection(0, 0, b.width, b.height, 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) {
		    if(comps[index] instanceof JComponent) {
			tmp2 = ((JComponent)comps[index])._bounds;
		    } else {
			tmp2 = comps[index].getBounds();
		    }		
					
		    if(tmp2.intersects(clip))
			return false;
		    index--;
		}
	    }
	    clip.x += b.x;
	    clip.y += b.y;
	    lastParent = parent;
	}
	if (parent == null) {
	    // No Window parent.
	    return false;
	}
	return true;
    }


/////////////////
// Accessibility support
////////////////

    /**
     * Get the AccessibleContext associated with this JComponent
     *
     * @return the AccessibleContext of this JComponent
     */
    public AccessibleContext getAccessibleContext() {
        if (accessibleContext == null) {
            accessibleContext = new AccessibleJViewport();
        }
        return accessibleContext;
    }

    /**
     * The class used to obtain the accessible role for this object.
     * <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.  A future release of Swing will provide support for
     * long term persistence.
     */
    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
}