| /* | |
| * Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved. | |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. | |
| * | |
| * This code is free software; you can redistribute it and/or modify it | |
| * under the terms of the GNU General Public License version 2 only, as | |
| * published by the Free Software Foundation. Oracle designates this | |
| * particular file as subject to the "Classpath" exception as provided | |
| * by Oracle in the LICENSE file that accompanied this code. | |
| * | |
| * This code is distributed in the hope that it will be useful, but WITHOUT | |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| * version 2 for more details (a copy is included in the LICENSE file that | |
| * accompanied this code). | |
| * | |
| * You should have received a copy of the GNU General Public License version | |
| * 2 along with this work; if not, write to the Free Software Foundation, | |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| * | |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA | |
| * or visit www.oracle.com if you need additional information or have any | |
| * questions. | |
| */ | |
| package javax.swing; | |
| import java.awt.*; | |
| import java.awt.event.*; | |
| import java.awt.geom.AffineTransform; | |
| import static java.awt.geom.AffineTransform.TYPE_FLIP; | |
| import static java.awt.geom.AffineTransform.TYPE_MASK_SCALE; | |
| import static java.awt.geom.AffineTransform.TYPE_TRANSLATION; | |
| import java.awt.image.AbstractMultiResolutionImage; | |
| import java.awt.image.ImageObserver; | |
| import java.awt.peer.ComponentPeer; | |
| import java.beans.BeanProperty; | |
| import java.beans.Transient; | |
| import javax.swing.plaf.ViewportUI; | |
| import javax.swing.event.*; | |
| import javax.swing.border.*; | |
| import javax.accessibility.*; | |
| import java.io.Serializable; | |
| import java.util.Arrays; | |
| import java.util.Collections; | |
| import sun.awt.AWTAccessor; | |
| import sun.swing.SwingUtilities2; | |
| /** | |
| * 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 are 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 | |
| * @since 1.2 | |
| */ | |
| @SuppressWarnings("serial") // Same-version serialization only | |
| 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. */ | |
| protected transient 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()); | |
| 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 | |
| * @since 1.3 | |
| */ | |
| @BeanProperty(hidden = true, visualUpdate = true, description | |
| = "The UI object that implements the Component's LookAndFeel.") | |
| 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 | |
| */ | |
| 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 | |
| * @throws 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 | |
| */ | |
| @BeanProperty(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 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); | |
| } | |
| boolean recreateBackingStoreImage = (backingStoreImage == null); | |
| int scaledWidth = width; | |
| int scaledHeight = height; | |
| if (g instanceof Graphics2D) { | |
| double sw = width; | |
| double sh = height; | |
| Graphics2D g2d = (Graphics2D) g; | |
| AffineTransform tx = g2d.getTransform(); | |
| int type = tx.getType(); | |
| if ((type & ~(TYPE_TRANSLATION | TYPE_FLIP)) == 0) { | |
| // skip | |
| } else if ((type & ~(TYPE_TRANSLATION | TYPE_FLIP | TYPE_MASK_SCALE)) == 0) { | |
| sw = Math.abs(width * tx.getScaleX()); | |
| sh = Math.abs(height * tx.getScaleY()); | |
| } else { | |
| sw = Math.abs(width * Math.hypot(tx.getScaleX(), tx.getShearY())); | |
| sh = Math.abs(height * Math.hypot(tx.getShearX(), tx.getScaleY())); | |
| } | |
| scaledWidth = (int) Math.ceil(sw); | |
| scaledHeight = (int) Math.ceil(sh); | |
| if (!recreateBackingStoreImage) { | |
| if (backingStoreImage instanceof BackingStoreMultiResolutionImage) { | |
| BackingStoreMultiResolutionImage mrImage | |
| = (BackingStoreMultiResolutionImage) backingStoreImage; | |
| recreateBackingStoreImage = (mrImage.scaledWidth != scaledWidth | |
| || mrImage.scaledHeight != scaledHeight); | |
| } else { | |
| recreateBackingStoreImage = (width != scaledWidth | |
| || height != scaledHeight); | |
| } | |
| } | |
| } | |
| if (recreateBackingStoreImage) { | |
| // 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 = createScaledImage(width, height, | |
| scaledWidth, scaledHeight); | |
| 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; | |
| } | |
| private Image createScaledImage(final int width, final int height, | |
| int scaledWidth, int scaledHeight) | |
| { | |
| if (scaledWidth == width && scaledHeight == height) { | |
| return createImage(width, height); | |
| } | |
| Image rvImage = createImage(scaledWidth, scaledHeight); | |
| return new BackingStoreMultiResolutionImage(width, height, | |
| scaledWidth, scaledHeight, rvImage); | |
| } | |
| static class BackingStoreMultiResolutionImage | |
| extends AbstractMultiResolutionImage { | |
| private final int width; | |
| private final int height; | |
| private final int scaledWidth; | |
| private final int scaledHeight; | |
| private final Image rvImage; | |
| public BackingStoreMultiResolutionImage(int width, int height, | |
| int scaledWidth, int scaledHeight, Image rvImage) { | |
| this.width = width; | |
| this.height = height; | |
| this.scaledWidth = scaledWidth; | |
| this.scaledHeight = scaledHeight; | |
| this.rvImage = rvImage; | |
| } | |
| @Override | |
| public int getWidth(ImageObserver observer) { | |
| return width; | |
| } | |
| @Override | |
| public int getHeight(ImageObserver observer) { | |
| return height; | |
| } | |
| @Override | |
| protected Image getBaseImage() { | |
| return rvImage; | |
| } | |
| @Override | |
| public Graphics getGraphics() { | |
| Graphics graphics = rvImage.getGraphics(); | |
| if (graphics instanceof Graphics2D) { | |
| double sx = (double) scaledWidth / width; | |
| double sy = (double) scaledHeight / height; | |
| ((Graphics2D) graphics).scale(sx, sy); | |
| } | |
| return graphics; | |
| } | |
| @Override | |
| public Image getResolutionVariant(double w, double h) { | |
| return rvImage; | |
| } | |
| @Override | |
| public java.util.List<Image> getResolutionVariants() { | |
| return Collections.unmodifiableList(Arrays.asList(rvImage)); | |
| } | |
| } | |
| /** | |
| * 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) | |
| */ | |
| @SuppressWarnings("deprecation") | |
| 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 | |
| * | |
| * @since 1.3 | |
| */ | |
| @BeanProperty(bound = false, enumerationValues = { | |
| "JViewport.BLIT_SCROLL_MODE", | |
| "JViewport.BACKINGSTORE_SCROLL_MODE", | |
| "JViewport.SIMPLE_SCROLL_MODE"}, description | |
| = "Method of moving contents for incremental scrolls.") | |
| 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() && !isFPScale(); | |
| } | |
| private boolean isFPScale() { | |
| GraphicsConfiguration gc = getGraphicsConfiguration(); | |
| if (gc != null) { | |
| return SwingUtilities2.isFloatingPointScale(gc.getDefaultTransform()); | |
| } | |
| return false; | |
| } | |
| /** | |
| * 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}. | |
| */ | |
| @SuppressWarnings("serial") // Same-version serialization only | |
| protected class ViewListener extends ComponentAdapter implements Serializable | |
| { | |
| /** | |
| * Constructs a {@code ViewListener}. | |
| */ | |
| protected ViewListener() {} | |
| 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 = AWTAccessor.getComponentAccessor() | |
| .getPeer(heavyParent); | |
| 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 disregard 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}. | |
| */ | |
| @SuppressWarnings("serial") // Same-version serialization only | |
| protected class AccessibleJViewport extends AccessibleJComponent { | |
| /** | |
| * Constructs an {@code AccessibleJViewport}. | |
| */ | |
| protected AccessibleJViewport() {} | |
| /** | |
| * 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 | |
| } |