| /* |
| * Copyright (c) 2000, 2008, 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 sun.awt.image; |
| |
| import java.awt.AlphaComposite; |
| import java.awt.Color; |
| import java.awt.Component; |
| import java.awt.Font; |
| import java.awt.Graphics2D; |
| import java.awt.GraphicsConfiguration; |
| import java.awt.ImageCapabilities; |
| import java.awt.Transparency; |
| import java.awt.image.BufferedImage; |
| import java.awt.image.ImageObserver; |
| import java.awt.image.VolatileImage; |
| import sun.java2d.SunGraphics2D; |
| import sun.java2d.SurfaceManagerFactory; |
| import sun.java2d.DestSurfaceProvider; |
| import sun.java2d.Surface; |
| import static sun.java2d.pipe.hw.AccelSurface.*; |
| |
| /** |
| * This class is the base implementation of the VolatileImage |
| * abstract class. The class implements most of the standard Image |
| * methods (width, height, etc.) but delegates all surface management |
| * issues to a platform-specific VolatileSurfaceManager. When a new instance |
| * of SunVolatileImage is created, it automatically creates an |
| * appropriate VolatileSurfaceManager for the GraphicsConfiguration |
| * under which this SunVolatileImage was created. |
| */ |
| public class SunVolatileImage extends VolatileImage |
| implements DestSurfaceProvider |
| { |
| |
| protected VolatileSurfaceManager volSurfaceManager; |
| protected Component comp; |
| private GraphicsConfiguration graphicsConfig; |
| private Font defaultFont; |
| private int width, height; |
| private int forcedAccelSurfaceType; |
| |
| protected SunVolatileImage(Component comp, |
| GraphicsConfiguration graphicsConfig, |
| int width, int height, Object context, |
| int transparency, ImageCapabilities caps, |
| int accType) |
| { |
| this.comp = comp; |
| this.graphicsConfig = graphicsConfig; |
| this.width = width; |
| this.height = height; |
| this.forcedAccelSurfaceType = accType; |
| if (!(transparency == Transparency.OPAQUE || |
| transparency == Transparency.BITMASK || |
| transparency == Transparency.TRANSLUCENT)) |
| { |
| throw new IllegalArgumentException("Unknown transparency type:" + |
| transparency); |
| } |
| this.transparency = transparency; |
| this.volSurfaceManager = createSurfaceManager(context, caps); |
| SurfaceManager.setManager(this, volSurfaceManager); |
| |
| // post-construction initialization of the surface manager |
| volSurfaceManager.initialize(); |
| // clear the background |
| volSurfaceManager.initContents(); |
| } |
| |
| private SunVolatileImage(Component comp, |
| GraphicsConfiguration graphicsConfig, |
| int width, int height, Object context, |
| ImageCapabilities caps) |
| { |
| this(comp, graphicsConfig, |
| width, height, context, Transparency.OPAQUE, caps, UNDEFINED); |
| } |
| |
| public SunVolatileImage(Component comp, int width, int height) { |
| this(comp, width, height, null); |
| } |
| |
| public SunVolatileImage(Component comp, |
| int width, int height, Object context) |
| { |
| this(comp, comp.getGraphicsConfiguration(), |
| width, height, context, null); |
| } |
| |
| public SunVolatileImage(GraphicsConfiguration graphicsConfig, |
| int width, int height, int transparency, |
| ImageCapabilities caps) |
| { |
| this(null, graphicsConfig, width, height, null, transparency, |
| caps, UNDEFINED); |
| } |
| |
| public int getWidth() { |
| return width; |
| } |
| |
| public int getHeight() { |
| return height; |
| } |
| |
| public GraphicsConfiguration getGraphicsConfig() { |
| return graphicsConfig; |
| } |
| |
| public void updateGraphicsConfig() { |
| // If this VImage is associated with a Component, get an updated |
| // graphicsConfig from that component. Otherwise, keep the one |
| // that we were created with |
| if (comp != null) { |
| GraphicsConfiguration gc = comp.getGraphicsConfiguration(); |
| if (gc != null) { |
| // Could potentially be null in some failure situations; |
| // better to keep the old non-null value around than to |
| // set graphicsConfig to null |
| graphicsConfig = gc; |
| } |
| } |
| } |
| |
| public Component getComponent() { |
| return comp; |
| } |
| |
| public int getForcedAccelSurfaceType() { |
| return forcedAccelSurfaceType; |
| } |
| |
| protected VolatileSurfaceManager createSurfaceManager(Object context, |
| ImageCapabilities caps) |
| { |
| /** |
| * Platform-specific SurfaceManagerFactories will return a |
| * manager suited to acceleration on each platform. But if |
| * the user is asking for a VolatileImage from a BufferedImageGC, |
| * then we need to return the appropriate unaccelerated manager. |
| * Note: this could change in the future; if some platform would |
| * like to accelerate BIGC volatile images, then this special-casing |
| * of the BIGC graphicsConfig should live in platform-specific |
| * code instead. |
| * We do the same for a Printer Device, and if user requested an |
| * unaccelerated VolatileImage by passing the capabilities object. |
| */ |
| if (graphicsConfig instanceof BufferedImageGraphicsConfig || |
| graphicsConfig instanceof sun.print.PrinterGraphicsConfig || |
| (caps != null && !caps.isAccelerated())) |
| { |
| return new BufImgVolatileSurfaceManager(this, context); |
| } |
| SurfaceManagerFactory smf = SurfaceManagerFactory.getInstance(); |
| return smf.createVolatileManager(this, context); |
| } |
| |
| private Color getForeground() { |
| if (comp != null) { |
| return comp.getForeground(); |
| } else { |
| return Color.black; |
| } |
| } |
| |
| private Color getBackground() { |
| if (comp != null) { |
| return comp.getBackground(); |
| } else { |
| return Color.white; |
| } |
| } |
| |
| private Font getFont() { |
| if (comp != null) { |
| return comp.getFont(); |
| } else { |
| if (defaultFont == null) { |
| defaultFont = new Font("Dialog", Font.PLAIN, 12); |
| } |
| return defaultFont; |
| } |
| } |
| |
| public Graphics2D createGraphics() { |
| return new SunGraphics2D(volSurfaceManager.getPrimarySurfaceData(), |
| getForeground(), |
| getBackground(), |
| getFont()); |
| } |
| |
| // Image method implementations |
| public Object getProperty(String name, ImageObserver observer) { |
| if (name == null) { |
| throw new NullPointerException("null property name is not allowed"); |
| } |
| return java.awt.Image.UndefinedProperty; |
| } |
| |
| public int getWidth(ImageObserver observer) { |
| return getWidth(); |
| } |
| |
| public int getHeight(ImageObserver observer) { |
| return getHeight(); |
| } |
| |
| /** |
| * This method creates a BufferedImage intended for use as a "snapshot" |
| * or a backup surface. |
| */ |
| public BufferedImage getBackupImage() { |
| return graphicsConfig.createCompatibleImage(getWidth(), getHeight(), |
| getTransparency()); |
| } |
| |
| public BufferedImage getSnapshot() { |
| BufferedImage bi = getBackupImage(); |
| Graphics2D g = bi.createGraphics(); |
| g.setComposite(AlphaComposite.Src); |
| g.drawImage(this, 0, 0, null); |
| g.dispose(); |
| return bi; |
| } |
| |
| public int validate(GraphicsConfiguration gc) { |
| return volSurfaceManager.validate(gc); |
| } |
| |
| public boolean contentsLost() { |
| return volSurfaceManager.contentsLost(); |
| } |
| |
| public ImageCapabilities getCapabilities() { |
| return volSurfaceManager.getCapabilities(graphicsConfig); |
| } |
| |
| /** |
| * {@inheritDoc} |
| * |
| * @see sun.java2d.DestSurfaceProvider#getDestSurface |
| */ |
| @Override |
| public Surface getDestSurface() { |
| return volSurfaceManager.getPrimarySurfaceData(); |
| } |
| } |