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