/*
* Copyright (c) 1997, 2009, 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;
import java.awt.AWTException;
import java.awt.BufferCapabilities;
import java.awt.Component;
import java.awt.Graphics;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.Image;
import java.awt.ImageCapabilities;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.awt.Transparency;
import java.awt.Window;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.awt.image.ColorModel;
import java.awt.image.DirectColorModel;
import java.awt.image.Raster;
import java.awt.image.VolatileImage;
import java.awt.image.WritableRaster;
import sun.awt.windows.WComponentPeer;
import sun.awt.image.OffScreenImage;
import sun.awt.image.SunVolatileImage;
import sun.awt.image.SurfaceManager;
import sun.java2d.SurfaceData;
import sun.java2d.InvalidPipeException;
import sun.java2d.loops.RenderLoops;
import sun.java2d.loops.SurfaceType;
import sun.java2d.loops.CompositeType;
import sun.java2d.windows.GDIWindowSurfaceData;
/**
* This is an implementation of a GraphicsConfiguration object for a
* single Win32 visual.
*
* @see GraphicsEnvironment
* @see GraphicsDevice
*/
public class Win32GraphicsConfig extends GraphicsConfiguration
implements DisplayChangedListener, SurfaceManager.ProxiedGraphicsConfig
{
protected Win32GraphicsDevice screen;
protected int visual; //PixelFormatID
protected RenderLoops solidloops;
private static native void initIDs();
static {
initIDs();
}
/**
* Returns a Win32GraphicsConfiguration object with the given device
* and PixelFormat. Note that this method does NOT check to ensure that
* the returned Win32GraphicsConfig will correctly support rendering into a
* Java window. This method is provided so that client code can do its
* own checking as to the appropriateness of a particular PixelFormat.
* Safer access to Win32GraphicsConfigurations is provided by
* Win32GraphicsDevice.getConfigurations().
*/
public static Win32GraphicsConfig getConfig(Win32GraphicsDevice device,
int pixFormatID)
{
return new Win32GraphicsConfig(device, pixFormatID);
}
/**
* @deprecated as of JDK version 1.3
* replaced by getConfig()
*/
@Deprecated
public Win32GraphicsConfig(GraphicsDevice device, int visualnum) {
this.screen = (Win32GraphicsDevice)device;
this.visual = visualnum;
((Win32GraphicsDevice)device).addDisplayChangedListener(this);
}
/**
* Return the graphics device associated with this configuration.
*/
public GraphicsDevice getDevice() {
return screen;
}
/**
* Return the PixelFormatIndex this GraphicsConfig uses
*/
public int getVisual() {
return visual;
}
public Object getProxyKey() {
return screen;
}
/**
* Return the RenderLoops this type of destination uses for
* solid fills and strokes.
*/
private SurfaceType sTypeOrig = null;
public synchronized RenderLoops getSolidLoops(SurfaceType stype) {
if (solidloops == null || sTypeOrig != stype) {
solidloops = SurfaceData.makeRenderLoops(SurfaceType.OpaqueColor,
CompositeType.SrcNoEa,
stype);
sTypeOrig = stype;
}
return solidloops;
}
/**
* Returns the color model associated with this configuration.
*/
public synchronized ColorModel getColorModel() {
return screen.getColorModel();
}
/**
* Returns a new color model for this configuration. This call
* is only used internally, by images and components that are
* associated with the graphics device. When attributes of that
* device change (for example, when the device palette is updated),
* then this device-based color model will be updated internally
* to reflect the new situation.
*/
public ColorModel getDeviceColorModel() {
return screen.getDynamicColorModel();
}
/**
* Returns the color model associated with this configuration that
* supports the specified transparency.
*/
public ColorModel getColorModel(int transparency) {
switch (transparency) {
case Transparency.OPAQUE:
return getColorModel();
case Transparency.BITMASK:
return new DirectColorModel(25, 0xff0000, 0xff00, 0xff, 0x1000000);
case Transparency.TRANSLUCENT:
return ColorModel.getRGBdefault();
default:
return null;
}
}
/**
* Returns the default Transform for this configuration. This
* Transform is typically the Identity transform for most normal
* screens. Device coordinates for screen and printer devices will
* have the origin in the upper left-hand corner of the target region of
* the device, with X coordinates
* increasing to the right and Y coordinates increasing downwards.
* For image buffers, this Transform will be the Identity transform.
*/
public AffineTransform getDefaultTransform() {
return new AffineTransform();
}
/**
*
* Returns a Transform that can be composed with the default Transform
* of a Graphics2D so that 72 units in user space will equal 1 inch
* in device space.
* Given a Graphics2D, g, one can reset the transformation to create
* such a mapping by using the following pseudocode:
*
* GraphicsConfiguration gc = g.getGraphicsConfiguration();
*
* g.setTransform(gc.getDefaultTransform());
* g.transform(gc.getNormalizingTransform());
*
* Note that sometimes this Transform will be identity (e.g. for
* printers or metafile output) and that this Transform is only
* as accurate as the information supplied by the underlying system.
* For image buffers, this Transform will be the Identity transform,
* since there is no valid distance measurement.
*/
public AffineTransform getNormalizingTransform() {
Win32GraphicsEnvironment ge = (Win32GraphicsEnvironment)
GraphicsEnvironment.getLocalGraphicsEnvironment();
double xscale = ge.getXResolution() / 72.0;
double yscale = ge.getYResolution() / 72.0;
return new AffineTransform(xscale, 0.0, 0.0, yscale, 0.0, 0.0);
}
public String toString() {
return (super.toString()+"[dev="+screen+",pixfmt="+visual+"]");
}
private native Rectangle getBounds(int screen);
public Rectangle getBounds() {
return getBounds(screen.getScreen());
}
public synchronized void displayChanged() {
solidloops = null;
}
public void paletteChanged() {}
/**
* The following methods are invoked from WComponentPeer.java rather
* than having the Win32-dependent implementations hardcoded in that
* class. This way the appropriate actions are taken based on the peer's
* GraphicsConfig, whether it is a Win32GraphicsConfig or a
* WGLGraphicsConfig.
*/
/**
* Creates a new SurfaceData that will be associated with the given
* WComponentPeer.
*/
public SurfaceData createSurfaceData(WComponentPeer peer,
int numBackBuffers)
{
return GDIWindowSurfaceData.createData(peer);
}
/**
* Creates a new managed image of the given width and height
* that is associated with the target Component.
*/
public Image createAcceleratedImage(Component target,
int width, int height)
{
ColorModel model = getColorModel(Transparency.OPAQUE);
WritableRaster wr =
model.createCompatibleWritableRaster(width, height);
return new OffScreenImage(target, model, wr,
model.isAlphaPremultiplied());
}
/**
* The following methods correspond to the multibuffering methods in
* WComponentPeer.java...
*/
/**
* Checks that the requested configuration is natively supported; if not,
* an AWTException is thrown.
*/
public void assertOperationSupported(Component target,
int numBuffers,
BufferCapabilities caps)
throws AWTException
{
// the default pipeline doesn't support flip buffer strategy
throw new AWTException(
"The operation requested is not supported");
}
/**
* This method is called from WComponentPeer when a surface data is replaced
* REMIND: while the default pipeline doesn't support flipping, it may
* happen that the accelerated device may have this graphics config
* (like if the device restoration failed when one device exits fs mode
* while others remain).
*/
public VolatileImage createBackBuffer(WComponentPeer peer) {
Component target = (Component)peer.getTarget();
return new SunVolatileImage(target,
target.getWidth(), target.getHeight(),
Boolean.TRUE);
}
/**
* Performs the native flip operation for the given target Component.
*
* REMIND: we should really not get here because that would mean that
* a FLIP BufferStrategy has been created, and one could only be created
* if accelerated pipeline is present but in some rare (and transitional)
* cases it may happen that the accelerated graphics device may have a
* default graphics configuraiton, so this is just a precaution.
*/
public void flip(WComponentPeer peer,
Component target, VolatileImage backBuffer,
int x1, int y1, int x2, int y2,
BufferCapabilities.FlipContents flipAction)
{
if (flipAction == BufferCapabilities.FlipContents.COPIED ||
flipAction == BufferCapabilities.FlipContents.UNDEFINED) {
Graphics g = peer.getGraphics();
try {
g.drawImage(backBuffer,
x1, y1, x2, y2,
x1, y1, x2, y2,
null);
} finally {
g.dispose();
}
} else if (flipAction == BufferCapabilities.FlipContents.BACKGROUND) {
Graphics g = backBuffer.getGraphics();
try {
g.setColor(target.getBackground());
g.fillRect(0, 0,
backBuffer.getWidth(),
backBuffer.getHeight());
} finally {
g.dispose();
}
}
// the rest of the flip actions are not supported
}
@Override
public boolean isTranslucencyCapable() {
//XXX: worth checking if 8-bit? Anyway, it doesn't hurt.
return true;
}
}