home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 November / Chip_1998-11_cd.bin / tema / Cafe / jfc.bin / JViewport.java < prev    next >
Text File  |  1998-02-26  |  21KB  |  718 lines
  1. /*
  2.  * @(#)JViewport.java    1.33 98/02/10
  3.  *
  4.  * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
  5.  *
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  *
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  *
  19.  */
  20.  
  21. package com.sun.java.swing;
  22.  
  23. import com.sun.java.swing.event.*;
  24. import com.sun.java.swing.border.*;
  25. import com.sun.java.accessibility.*;
  26.  
  27. import java.awt.Component;
  28. import java.awt.Container;
  29. import java.awt.LayoutManager;
  30. import java.awt.Dimension;
  31. import java.awt.Rectangle;
  32. import java.awt.Point;
  33. import java.awt.Insets;
  34. import java.awt.Graphics;
  35. import java.awt.Image;
  36. import java.awt.event.ComponentListener;
  37. import java.awt.event.ComponentAdapter;
  38. import java.awt.event.ComponentEvent;
  39.  
  40. import java.io.Serializable;
  41.  
  42.  
  43. /**
  44.  * The "view port" through which you see information as it scrolls
  45.  * by underneath the "port hole". Kind of like moving a square
  46.  * magnifying glass up and down a page. Moving the magnifying glass
  47.  * up brings the contents above into view.
  48.  * <p>
  49.  * Warning: serialized objects of this class will not be compatible with
  50.  * future swing releases.  The current serialization support is appropriate
  51.  * for short term storage or RMI between Swing1.0 applications.  It will
  52.  * not be possible to load serialized Swing1.0 objects with future releases
  53.  * of Swing.  The JDK1.2 release of Swing will be the compatibility
  54.  * baseline for the serialized form of Swing objects.
  55.  *
  56.  * @version 1.33 02/10/98
  57.  * @author Hans Muller
  58.  * @author Philip Milne
  59.  */
  60. public class JViewport extends JComponent implements Accessible
  61. {
  62.     protected boolean isViewSizeSet = false;
  63.  
  64.     /**
  65.      * The last viewPosition that we've painted, so we know how
  66.      * much of the backing store image is valid.
  67.      */
  68.     protected Point lastPaintPosition = null;
  69.  
  70.     protected boolean backingStore = false;
  71.     transient protected Image backingStoreImage = null;
  72.  
  73.     /*
  74.      * The scrollUnderway flag is used for components like JList.
  75.      * When the downarrow key is pressed on a JList and the selected
  76.      * cell is the last in the list, the scrollpane autoscrolls.
  77.      * Here, the old selected cell needs repainting and so we need
  78.      * a flag to make the viewport do the optimised painting
  79.      * only when there is an explicit call to setViewPosition(Point).
  80.      * When setBounds() is called through other routes,
  81.      * the flag is off and the view repaints normally.
  82.      * Another approach would be to remove this from the Viewport
  83.      * class and have the JList manage this case by using
  84.      * setBackingStoreEnabled().
  85.      */
  86.     protected boolean scrollUnderway = false;
  87.  
  88.     /**
  89.      * Listener that's notified each time the view changes size.
  90.      */
  91.     private ComponentListener viewListener = null;
  92.  
  93.     /* Only one ChangeEvent is needed per JViewport instance since the
  94.      * event's only (read-only) state is the source property.  The source
  95.      * of events generated here is always "this".
  96.      */
  97.     private transient ChangeEvent changeEvent = null;
  98.  
  99.  
  100.     public JViewport() {
  101.     super();
  102.     setLayout(createLayoutManager());
  103.     }
  104.  
  105.  
  106.     /**
  107.      * Sets the Viewports one lightweight child, child can be null.
  108.      *
  109.      * @see #setView
  110.      */
  111.     protected void addImpl(Component child, Object constraints, int index) {
  112.       setView(child);
  113.     }
  114.  
  115.  
  116.     public void remove(Component child) {
  117.     child.removeComponentListener(viewListener);
  118.     super.remove(child);
  119.     }
  120.  
  121.  
  122.     /**
  123.      * Overridden to scroll the View such that <b>aRect</b> within the
  124.      * View becomes visible.
  125.      */
  126.     public void scrollRectToVisible(Rectangle contentRect) {
  127.         Component view = getView();
  128.  
  129.         if (view == null) {
  130.             return;
  131.         } else {
  132.             int     dx = 0, dy = 0;
  133.             Rectangle bounds = getBounds();
  134.  
  135.             dx = positionAdjustment(bounds.width, contentRect.width, contentRect.x);
  136.             dy = positionAdjustment(bounds.height, contentRect.height, contentRect.y);
  137.  
  138.             if (dx != 0 || dy != 0) {
  139.                 Point viewPosition = getViewPosition();
  140.                 setViewPosition(new Point(viewPosition.x - dx, viewPosition.y - dy));
  141.                 scrollUnderway = false;
  142.             }
  143.         }
  144.     }
  145.  
  146.     /**  This method is used by the scrollToRect method to determine the
  147.       *  proper direction and amount to move by. The ivars here are named
  148.       *  width, but this is applicable to height also. The code assumes that
  149.       *  parentWidth/childWidth are positive and childAt can be negative.
  150.       */
  151.     private int positionAdjustment(int parentWidth, int childWidth, int childAt)    {
  152.  
  153.         //   +-----+
  154.         //   | --- |     No Change
  155.         //   +-----+
  156.         if (childAt >= 0 && childWidth + childAt <= parentWidth)    {
  157.             return 0;
  158.         }
  159.  
  160.         //   +-----+
  161.         //  ---------   No Change
  162.         //   +-----+
  163.         if (childAt <= 0 && childWidth + childAt >= parentWidth) {
  164.             return 0;
  165.         }
  166.  
  167.         //   +-----+          +-----+
  168.         //   |   ----    ->   | ----|
  169.         //   +-----+          +-----+
  170.         if (childAt > 0 && childWidth <= parentWidth)    {
  171.             return -childAt + parentWidth - childWidth;
  172.         }
  173.  
  174.         //   +-----+             +-----+
  175.         //   |  --------  ->     |--------
  176.         //   +-----+             +-----+
  177.         if (childAt >= 0 && childWidth >= parentWidth)   {
  178.             return -childAt;
  179.         }
  180.  
  181.         //   +-----+          +-----+
  182.         // ----    |     ->   |---- |
  183.         //   +-----+          +-----+
  184.         if (childAt <= 0 && childWidth <= parentWidth)   {
  185.             return -childAt;
  186.         }
  187.  
  188.         //   +-----+             +-----+
  189.         //-------- |      ->   --------|
  190.         //   +-----+             +-----+
  191.         if (childAt < 0 && childWidth >= parentWidth)    {
  192.             return -childAt + parentWidth - childWidth;
  193.         }
  194.  
  195.         return 0;
  196.     }
  197.  
  198.  
  199.     /**
  200.      * The viewport "scrolls" it's child (called the "view") by the
  201.      * normal parent/child clipping (typically the view is moved in
  202.      * the opposite direction of the scroll).  A non-null border,
  203.      * or non-zero insets, isn't supported, to prevent the geometry
  204.      * of this component from becoming complex enough to inhibit
  205.      * subclassing.  To createa JViewport with a border, add it to a
  206.      * JPanel that has a border.
  207.      */
  208.     public final void setBorder(Border border) {
  209.     if (border != null) {
  210.         throw new IllegalArgumentException("JViewport.setBorder() not supported");
  211.     }
  212.     }
  213.  
  214.  
  215.     /**
  216.      * @return new Insets(0, 0, 0, 0)
  217.      * @see #setBorder
  218.      */
  219.     public final Insets getInsets() {
  220.     return new Insets(0, 0, 0, 0);
  221.     }
  222.  
  223.  
  224.     private Graphics getBackingStoreGraphics(Graphics g) {
  225.         Graphics bsg = backingStoreImage.getGraphics();
  226.     bsg.setColor(g.getColor());
  227.         bsg.setFont(g.getFont());
  228.         bsg.setClip(g.getClipBounds());
  229.         return bsg;
  230.     }
  231.  
  232.  
  233.     private void paintViaBackingStore(Graphics g) {
  234.         Graphics bsg = getBackingStoreGraphics(g);
  235.         super.paint(bsg);
  236.         g.drawImage(backingStoreImage, 0, 0, this);
  237.     }
  238.  
  239.     /*
  240.      * The JViewport overrides the default implementation of
  241.      * this method (in JComponent) to return false. This ensures
  242.      * that the drawing machinery will call the Viewport's paint()
  243.      * implementation rather than messaging the JViewport's
  244.      * children directly.
  245.      */
  246.     public boolean isOptimizedDrawingEnabled() {
  247.     return false;
  248.     }
  249.  
  250.     /**
  251.      * Depending on whether the backingStore is enabled,
  252.      * either paint the image through the backing store or paint
  253.      * just the recently exposed part, using the backing store
  254.      * to "blit" the remainder.
  255.      */
  256.     public void paint(Graphics g)
  257.     {
  258.     int width = getWidth();
  259.     int height = getHeight();
  260.  
  261.     if ((width == 0) || (height == 0)) {
  262.         return;
  263.     }
  264.  
  265.     if (!backingStore) {
  266.         super.paint(g);
  267.             lastPaintPosition = getViewLocation();
  268.             return;
  269.     }
  270.  
  271.     if (backingStoreImage == null) {
  272.             // Backing store is enabled but this is the first call to paint.
  273.             // Create the backing store, paint it and then copy to g.
  274.             backingStoreImage = createImage(width, height);
  275.             paintViaBackingStore(g);
  276.         }
  277.     else {
  278.             if (!scrollUnderway || lastPaintPosition.equals(getViewLocation())) {
  279.                 // No scrolling happened: repaint required area via backing store.
  280.                 paintViaBackingStore(g);
  281.             } else {
  282.                 // The image was scrolled. Manipulate the backing store and flush it to g.
  283.                    Point blitFrom = new Point();
  284.             Point blitTo = new Point();
  285.             Dimension blitSize = new Dimension();
  286.             Rectangle blitPaint = new Rectangle();
  287.  
  288.                 Point newLocation = getViewLocation();
  289.             int dx = newLocation.x - lastPaintPosition.x;
  290.             int dy = newLocation.y - lastPaintPosition.y;
  291.              boolean canBlit = computeBlit(dx, dy, blitFrom, blitTo, blitSize, blitPaint);
  292.         if (!canBlit) {
  293.                     // The image was either moved diagonally or
  294.                     // moved by more than the image size: paint normally.
  295.                     paintViaBackingStore(g);
  296.                 } else {
  297.                     int bdx = blitTo.x - blitFrom.x;
  298.             int bdy = blitTo.y - blitFrom.y;
  299.  
  300.                     // Move the relevant part of the backing store.
  301.                     Graphics bsg = getBackingStoreGraphics(g);
  302.                     bsg.copyArea(blitFrom.x, blitFrom.y, blitSize.width, blitSize.height, bdx, bdy);
  303.  
  304.                     // Paint the rest of the view; the part that has just been exposed.
  305.                     Rectangle r = getView().getBounds().intersection(blitPaint);
  306.                 bsg.setClip(r);
  307.                     super.paint(bsg);
  308.  
  309.                     // Copy whole of the backing store to g.
  310.             g.drawImage(backingStoreImage, 0, 0, this);
  311.                 }
  312.             }
  313.         }
  314.         lastPaintPosition = getViewLocation();
  315.         scrollUnderway = false;
  316.     }
  317.  
  318.  
  319.     public void setBounds(int x, int y, int w, int h) {
  320.     Dimension size = getSize();
  321.     if ((size.width != w) || (size.height != h)) {
  322.         backingStoreImage = null;
  323.     }
  324.     super.setBounds(x, y, w, h);
  325.     }
  326.  
  327.  
  328.     /**
  329.      * Returns true if this viewport is maintaining an offscreen
  330.      * image of its contents.
  331.      */
  332.     public boolean isBackingStoreEnabled() {
  333.     return backingStore;
  334.     }
  335.  
  336.  
  337.     /**
  338.      * If true if this viewport will maintain an offscreen
  339.      * image of its contents.  The image is used to reduce the cost
  340.      * of small one dimensional changes to the viewPosition.
  341.      * Rather than repainting the entire viewport we use
  342.      * Graphics.copyArea() to effect some of the scroll.
  343.      */
  344.  
  345.     public void setBackingStoreEnabled(boolean x) {
  346.     backingStore = x;
  347.     }
  348.  
  349.  
  350.     /**
  351.      * Returns the Viewports one child or null.
  352.      *
  353.      * @see #setView
  354.      */
  355.     public Component getView() {
  356.     return (getComponentCount() > 0) ? getComponent(0) : null;
  357.     }
  358.  
  359.     /**
  360.      * Sets the Viewports one lightweight child, <code>view</code>
  361.      * can be null.
  362.      *
  363.      * @see #getView
  364.      */
  365.     public void setView(Component view) {
  366.  
  367.     /* Remove the viewports existing children, if any.
  368.      * Note that removeAll() isn't used here because it
  369.      * doesn't call remove() (which JViewport overrides).
  370.      */
  371.     int n = getComponentCount();
  372.     for(int i = n - 1; i >= 0; i--) {
  373.         remove(i);
  374.     }
  375.  
  376.     isViewSizeSet = false;
  377.  
  378.     if (view != null) {
  379.         super.addImpl(view, null, -1);
  380.         viewListener = createViewListener();
  381.         view.addComponentListener(viewListener);
  382.     }
  383.     }
  384.  
  385.  
  386.     /**
  387.      * If the views size hasn't been explicitly set return the
  388.      * preferred size, otherwise return the views current size.
  389.      * If there's no view return 0,0.
  390.      */
  391.     public Dimension getViewSize() {
  392.     Component view = getView();
  393.  
  394.     if (view == null) {
  395.         return new Dimension(0,0);
  396.     }
  397.     else if (isViewSizeSet) {
  398.         return view.getSize();
  399.     }
  400.     else {
  401.         return view.getPreferredSize();
  402.     }
  403.     }
  404.  
  405.  
  406.     /**
  407.      * Sets the view coordinates that appear in the upper left
  408.      * hand corner of the viewport, null if there's no view.
  409.      */
  410.     public void setViewSize(Dimension newSize) {
  411.     Component view = getView();
  412.     if (view != null) {
  413.         Dimension oldSize = view.getSize();
  414.         if (!newSize.equals(oldSize)) {
  415.         view.setSize(newSize);
  416.         isViewSizeSet = true;
  417.         fireStateChanged();
  418.         }
  419.     }
  420.     }
  421.  
  422.     /**
  423.      * Returns the view coordinates that appear in the upper left
  424.      * hand corner of the viewport, 0,0 if there's no view.
  425.      */
  426.     public Point getViewPosition() {
  427.     Component view = getView();
  428.     if (view != null) {
  429.         Point p = view.getLocation();
  430.         p.x = -p.x;
  431.         p.y = -p.y;
  432.         return p;
  433.     }
  434.     else {
  435.         return new Point(0,0);
  436.     }
  437.     }
  438.  
  439.     private Point getViewLocation() {
  440.     Component view = getView();
  441.     if (view != null) {
  442.         return view.getLocation();
  443.     }
  444.     else {
  445.         return new Point(0,0);
  446.     }
  447.     }
  448.  
  449.     /**
  450.      * Sets the view coordinates that appear in the upper left
  451.      * hand corner of the viewport, null if there's no view.
  452.      */
  453.     public void setViewPosition(Point p) {
  454.     Component view = getView();
  455.     if (view != null) {
  456.             // The view scrolls in the opposite direction to mouse movement.
  457.             p = new Point(-p.x, -p.y);
  458.         if (!p.equals(view.getLocation())) {
  459.         scrollUnderway = true;
  460.         view.setLocation(p); // This calls setBounds(), and then repaint().
  461.  
  462.                 // Mustn't do this if the view hasn't moved otherwise we loop indefinitely. (?)
  463.         fireStateChanged();
  464.             }
  465.     }
  466.     }
  467.  
  468.  
  469.     /**
  470.      * Return a rectangle whose origin is getViewPosition and size is
  471.      * getExtentSize().  This is the visible part of the view, in view
  472.      * coordinates.
  473.      *
  474.      * @return The visible part of the view, in view coordinates.
  475.      */
  476.     public Rectangle getViewRect() {
  477.     return new Rectangle(getViewPosition(), getExtentSize());
  478.     }
  479.  
  480.  
  481.     /**
  482.      * Computes the parameters for a blit where the backing store image
  483.      * currently contains oldLoc in the upper left hand corner
  484.      * and we're scrolling to newLoc.  The blit* parameters are returned.
  485.      */
  486.     protected boolean computeBlit(
  487.         int dx,
  488.         int dy,
  489.         Point blitFrom,
  490.         Point blitTo,
  491.         Dimension blitSize,
  492.     Rectangle blitPaint)
  493.     {
  494.     int dxAbs = Math.abs(dx);
  495.     int dyAbs = Math.abs(dy);
  496.     Dimension extentSize = getExtentSize();
  497.  
  498.     if ((dx == 0) && (dy != 0) && (dyAbs < extentSize.height)) {
  499.         if (dy < 0) {
  500.         blitFrom.y = -dy;
  501.         blitTo.y = 0;
  502.         blitPaint.y = extentSize.height + dy;
  503.         }
  504.         else {
  505.         blitFrom.y = 0;
  506.         blitTo.y = dy;
  507.         blitPaint.y = 0;
  508.         }
  509.  
  510.         blitPaint.x = blitFrom.x = blitTo.x = 0;
  511.  
  512.         blitSize.width = extentSize.width;
  513.         blitSize.height = extentSize.height - dyAbs;
  514.  
  515.         blitPaint.width = extentSize.width;
  516.         blitPaint.height = dyAbs;
  517.  
  518.         return true;
  519.     }
  520.  
  521.     else if ((dy == 0) && (dx != 0) && (dxAbs < extentSize.width)) {
  522.         if (dx < 0) {
  523.         blitFrom.x = -dx;
  524.         blitTo.x = 0;
  525.         blitPaint.x = extentSize.width + dx;
  526.         }
  527.         else {
  528.         blitFrom.x = 0;
  529.         blitTo.x = dx;
  530.         blitPaint.x = 0;
  531.         }
  532.  
  533.         blitPaint.y = blitFrom.y = blitTo.y = 0;
  534.  
  535.         blitSize.width = extentSize.width - dxAbs;
  536.         blitSize.height = extentSize.height;
  537.  
  538.         blitPaint.y = 0;
  539.         blitPaint.width = dxAbs;
  540.         blitPaint.height = extentSize.height;
  541.  
  542.         return true;
  543.     }
  544.  
  545.     else {
  546.         return false;
  547.     }
  548.     }
  549.  
  550.  
  551.     /**
  552.      * Returns the size of the visible part of the view in view coordinates.
  553.      */
  554.     public Dimension getExtentSize() {
  555.     return getSize();
  556.     }
  557.  
  558.  
  559.     /**
  560.      * Convert a size in pixel coordinates to view coordinates.
  561.      * Subclasses of viewport that support "logical coordinates"
  562.      * will override this method.
  563.      */
  564.     public Dimension toViewCoordinates(Dimension size) {
  565.     return new Dimension(size);
  566.     }
  567.  
  568.     /**
  569.      * Convert a point in pixel coordinates to view coordinates.
  570.      * Subclasses of viewport that support "logical coordinates"
  571.      * will override this method.
  572.      */
  573.     public Point toViewCoordinates(Point p) {
  574.     return new Point(p);
  575.     }
  576.  
  577.  
  578.     /**
  579.      * Set the size of the visible part of the view, newExtent is
  580.      * in view coordinates.
  581.      */
  582.     public void setExtentSize(Dimension newExtent) {
  583.     Dimension oldExtent = getExtentSize();
  584.     if (!newExtent.equals(oldExtent)) {
  585.         setSize(newExtent);
  586.         fireStateChanged();
  587.     }
  588.     }
  589.  
  590.     /**
  591.      * A listener for the view.
  592.      * <p>
  593.      * Warning: serialized objects of this class will not be compatible with
  594.      * future swing releases.  The current serialization support is appropriate
  595.      * for short term storage or RMI between Swing1.0 applications.  It will
  596.      * not be possible to load serialized Swing1.0 objects with future releases
  597.      * of Swing.  The JDK1.2 release of Swing will be the compatibility
  598.      * baseline for the serialized form of Swing objects.
  599.      */
  600.     protected class ViewListener extends ComponentAdapter implements Serializable
  601.     {
  602.     public void componentResized(ComponentEvent e) {
  603.         fireStateChanged();
  604.     }
  605.     }
  606.  
  607.     protected ViewListener createViewListener() {
  608.     return new ViewListener();
  609.     }
  610.  
  611.  
  612.     /**
  613.      * Subclassers can override this to install a different
  614.      * layout manager (or null) in the constructor.  Returns
  615.      * a new JViewportLayout object.
  616.      */
  617.     protected LayoutManager createLayoutManager() {
  618.     return new ViewportLayout();
  619.     }
  620.  
  621.  
  622.     /**
  623.      * Add a ChangeListener to the list that's notified each time the views
  624.      * size, position, or the viewports extent size has changed.
  625.      *
  626.      * @see #removeChangeListener
  627.      * @see #setViewPosition
  628.      * @see #setViewSize
  629.      * @see #setExtentSize
  630.      */
  631.     public void addChangeListener(ChangeListener l) {
  632.     listenerList.add(ChangeListener.class, l);
  633.     }
  634.  
  635.     /**
  636.      * Remove a ChangeListener from the list that's notified each
  637.      * time the views size, position, or the viewports extent size
  638.      * has changed.
  639.      *
  640.      * @see #addChangeListener
  641.      */
  642.     public void removeChangeListener(ChangeListener l) {
  643.     listenerList.remove(ChangeListener.class, l);
  644.     }
  645.  
  646.  
  647.     /*
  648.      * Notify all ChangeListeners when the views
  649.      * size, position, or the viewports extent size has changed.
  650.      *
  651.      * @see #addChangeListener
  652.      * @see #removeChangeListener
  653.      * @see EventListenerList
  654.      */
  655.     protected void fireStateChanged()
  656.     {
  657.     Object[] listeners = listenerList.getListenerList();
  658.     for (int i = listeners.length - 2; i >= 0; i -= 2) {
  659.         if (listeners[i] == ChangeListener.class) {
  660.         if (changeEvent == null) {
  661.             changeEvent = new ChangeEvent(this);
  662.         }
  663.         ((ChangeListener)listeners[i + 1]).stateChanged(changeEvent);
  664.         }
  665.     }
  666.     }
  667.  
  668.     /** We always repaint in our parent coordinate system to make sure
  669.      *  only one paint is performed by the RepaintManager
  670.      */
  671.     public void repaint(long tm, int x, int y, int w,int h) {
  672.         Container parent = getParent();
  673.         if(parent != null)
  674.             parent.repaint(tm,x+getX(),y+getY(),w,h);
  675.         else
  676.             super.repaint(tm,x,y,w,h);
  677.     }
  678.  
  679.  
  680. /////////////////
  681. // Accessibility support
  682. ////////////////
  683.  
  684.     /**
  685.      * Get the AccessibleContext associated with this JComponent
  686.      *
  687.      * @return the AccessibleContext of this JComponent
  688.      */
  689.     public AccessibleContext getAccessibleContext() {
  690.     if (accessibleContext == null) {
  691.         accessibleContext = new AccessibleJViewport();
  692.     }
  693.     return accessibleContext;
  694.     }
  695.  
  696.     /**
  697.      * The class used to obtain the accessible role for this object.
  698.      * <p>
  699.      * Warning: serialized objects of this class will not be compatible with
  700.      * future swing releases.  The current serialization support is appropriate
  701.      * for short term storage or RMI between Swing1.0 applications.  It will
  702.      * not be possible to load serialized Swing1.0 objects with future releases
  703.      * of Swing.  The JDK1.2 release of Swing will be the compatibility
  704.      * baseline for the serialized form of Swing objects.
  705.      */
  706.     protected class AccessibleJViewport extends AccessibleJComponent {
  707.         /**
  708.          * Get the role of this object.
  709.          *
  710.          * @return an instance of AccessibleRole describing the role of
  711.      * the object
  712.          */
  713.         public AccessibleRole getAccessibleRole() {
  714.             return AccessibleRole.VIEWPORT;
  715.         }
  716.     } // inner class AccessibleJViewport
  717. }
  718.