| /* |
| * Copyright 2000-2007 Sun Microsystems, Inc. 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. Sun designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, |
| * CA 95054 USA or visit www.sun.com if you need additional information or |
| * have any questions. |
| */ |
| |
| package sun.java2d.windows; |
| import java.awt.GraphicsConfiguration; |
| import java.awt.Image; |
| import java.awt.Rectangle; |
| import java.awt.Transparency; |
| import java.awt.color.ColorSpace; |
| import java.awt.image.ColorModel; |
| import java.awt.image.ComponentColorModel; |
| import java.awt.image.DirectColorModel; |
| import java.awt.image.IndexColorModel; |
| import java.awt.image.Raster; |
| |
| import sun.awt.SunHints; |
| import sun.awt.Win32GraphicsConfig; |
| import sun.awt.Win32GraphicsDevice; |
| import sun.awt.image.SurfaceManager; |
| import sun.awt.image.SunVolatileImage; |
| import sun.awt.image.WritableRasterNative; |
| import sun.java2d.SunGraphics2D; |
| import sun.java2d.SurfaceData; |
| import sun.java2d.SurfaceDataProxy; |
| import sun.java2d.loops.CompositeType; |
| import sun.java2d.pipe.PixelToShapeConverter; |
| import sun.java2d.loops.GraphicsPrimitive; |
| import sun.java2d.loops.SurfaceType; |
| import sun.java2d.loops.RenderLoops; |
| import sun.java2d.pipe.Region; |
| |
| /** |
| * Win32OffScreenSurfaceData |
| * |
| * This class implements a hardware-accelerated video memory surface. It uses |
| * a custom renderer (DDRenderer) to render via DirectDraw into the |
| * surface and uses a custom Blit loop (DDBlitLoops) to copy between |
| * two hardware-accelerated surfaces (including the screen). |
| */ |
| public class Win32OffScreenSurfaceData extends SurfaceData { |
| |
| protected int width; |
| protected int height; |
| protected int transparency; |
| |
| protected GraphicsConfiguration graphicsConfig; |
| protected Image image; |
| protected RenderLoops solidloops; |
| private boolean ddSurfacePunted = false; |
| |
| private static native void initIDs(); |
| |
| static { |
| initIDs(); |
| // REMIND: This isn't really thought-out; if the user doesn't have or |
| // doesn't want ddraw then we should not even have this surface type |
| // in the loop |
| if (WindowsFlags.isDDEnabled() && WindowsFlags.isDDOffscreenEnabled()) { |
| if (WindowsFlags.isDDBlitEnabled()) { |
| // Register out hardware-accelerated Blit loops |
| DDBlitLoops.register(); |
| } |
| if (WindowsFlags.isDDScaleEnabled()) { |
| DDScaleLoops.register(); |
| } |
| } |
| } |
| |
| public static SurfaceType getSurfaceType(ColorModel cm, int transparency) { |
| boolean transparent = (transparency == Transparency.BITMASK); |
| switch (cm.getPixelSize()) { |
| case 32: |
| case 24: |
| if (cm instanceof DirectColorModel) { |
| if (((DirectColorModel)cm).getRedMask() == 0xff0000) { |
| return transparent ? Win32SurfaceData.IntRgbDD_BM : |
| Win32SurfaceData.IntRgbDD; |
| } else { |
| return transparent ? Win32SurfaceData.IntRgbxDD_BM : |
| Win32SurfaceData.IntRgbxDD; |
| } |
| } else { |
| return transparent ? Win32SurfaceData.ThreeByteBgrDD_BM : |
| Win32SurfaceData.ThreeByteBgrDD; |
| } |
| case 15: |
| return transparent ? Win32SurfaceData.Ushort555RgbDD_BM : |
| Win32SurfaceData.Ushort555RgbDD; |
| case 16: |
| if ((cm instanceof DirectColorModel) && |
| (((DirectColorModel)cm).getBlueMask() == 0x3e)) |
| { |
| return transparent ? Win32SurfaceData.Ushort555RgbxDD_BM : |
| Win32SurfaceData.Ushort555RgbxDD; |
| } else { |
| return transparent ? Win32SurfaceData.Ushort565RgbDD_BM : |
| Win32SurfaceData.Ushort565RgbDD; |
| } |
| case 8: |
| if (cm.getColorSpace().getType() == ColorSpace.TYPE_GRAY && |
| cm instanceof ComponentColorModel) { |
| return transparent ? Win32SurfaceData.ByteGrayDD_BM : |
| Win32SurfaceData.ByteGrayDD; |
| } else if (cm instanceof IndexColorModel && |
| isOpaqueGray((IndexColorModel)cm)) { |
| return transparent ? Win32SurfaceData.Index8GrayDD_BM : |
| Win32SurfaceData.Index8GrayDD; |
| } else { |
| return transparent ? Win32SurfaceData.ByteIndexedDD_BM : |
| Win32SurfaceData.ByteIndexedOpaqueDD; |
| } |
| default: |
| throw new sun.java2d.InvalidPipeException("Unsupported bit " + |
| "depth: " + |
| cm.getPixelSize()); |
| } |
| } |
| |
| @Override |
| public SurfaceDataProxy makeProxyFor(SurfaceData srcData) { |
| Win32GraphicsConfig wgc = (Win32GraphicsConfig) graphicsConfig; |
| return Win32SurfaceDataProxy.createProxy(srcData, wgc); |
| } |
| |
| public static Win32OffScreenSurfaceData |
| createData(int width, int height, |
| ColorModel cm, Win32GraphicsConfig gc, |
| Image image, int transparency) |
| { |
| // Win32OSD doesn't support acceleration of translucent images |
| if (transparency == Transparency.TRANSLUCENT) { |
| return null; |
| } |
| |
| |
| Win32GraphicsDevice gd = (Win32GraphicsDevice)gc.getDevice(); |
| if (!gd.isOffscreenAccelerationEnabled()) |
| { |
| // If acceleration for this type of image is disabled on this |
| // device, do not create an accelerated surface type |
| return null; |
| } |
| |
| return new Win32OffScreenSurfaceData(width, height, |
| getSurfaceType(cm, transparency), |
| cm, gc, image, transparency, |
| gd.getScreen()); |
| } |
| |
| protected static DDRenderer ddPipe; |
| protected static PixelToShapeConverter ddTxPipe; |
| |
| static { |
| ddPipe = new DDRenderer(); |
| if (GraphicsPrimitive.tracingEnabled()) { |
| ddPipe = ddPipe.traceWrapDD(); |
| } |
| ddTxPipe = new PixelToShapeConverter(ddPipe); |
| } |
| |
| public void validatePipe(SunGraphics2D sg2d) { |
| if (sg2d.antialiasHint != SunHints.INTVAL_ANTIALIAS_ON && |
| sg2d.paintState <= sg2d.PAINT_ALPHACOLOR && |
| sg2d.compositeState <= sg2d.COMP_ISCOPY && |
| sg2d.clipState != sg2d.CLIP_SHAPE && |
| transparency != Transparency.TRANSLUCENT) |
| { |
| PixelToShapeConverter txPipe; |
| DDRenderer nontxPipe; |
| txPipe = ddTxPipe; |
| nontxPipe = ddPipe; |
| sg2d.imagepipe = imagepipe; |
| if (sg2d.transformState >= sg2d.TRANSFORM_TRANSLATESCALE) { |
| sg2d.drawpipe = txPipe; |
| sg2d.fillpipe = txPipe; |
| } else if (sg2d.strokeState != sg2d.STROKE_THIN){ |
| sg2d.drawpipe = txPipe; |
| sg2d.fillpipe = nontxPipe; |
| } else { |
| sg2d.drawpipe = nontxPipe; |
| sg2d.fillpipe = nontxPipe; |
| } |
| sg2d.shapepipe = nontxPipe; |
| switch (sg2d.textAntialiasHint) { |
| |
| case SunHints.INTVAL_TEXT_ANTIALIAS_DEFAULT: |
| /* equate DEFAULT to OFF which it is for us */ |
| case SunHints.INTVAL_TEXT_ANTIALIAS_OFF: |
| sg2d.textpipe = solidTextRenderer; |
| break; |
| |
| case SunHints.INTVAL_TEXT_ANTIALIAS_ON: |
| sg2d.textpipe = aaTextRenderer; |
| break; |
| |
| default: |
| switch (sg2d.getFontInfo().aaHint) { |
| |
| case SunHints.INTVAL_TEXT_ANTIALIAS_LCD_HRGB: |
| case SunHints.INTVAL_TEXT_ANTIALIAS_LCD_VRGB: |
| sg2d.textpipe = lcdTextRenderer; |
| break; |
| |
| case SunHints.INTVAL_TEXT_ANTIALIAS_ON: |
| sg2d.textpipe = aaTextRenderer; |
| break; |
| |
| default: |
| sg2d.textpipe = solidTextRenderer; |
| } |
| } |
| // This is needed for AA text. |
| // Note that even a SolidTextRenderer can dispatch AA text |
| // if a GlyphVector overrides the AA setting. |
| sg2d.loops = solidloops; |
| } else { |
| super.validatePipe(sg2d); |
| } |
| } |
| |
| public static boolean isDDScaleEnabled() { |
| return WindowsFlags.isDDScaleEnabled(); |
| } |
| |
| private WritableRasterNative wrn = null; |
| public synchronized Raster getRaster(int x, int y, int w, int h) { |
| if (wrn == null) { |
| wrn = WritableRasterNative.createNativeRaster(getColorModel(), |
| this, |
| width, height); |
| if (wrn == null) { |
| throw new InternalError("Unable to create native raster"); |
| } |
| } |
| |
| return wrn; |
| } |
| |
| public RenderLoops getRenderLoops(SunGraphics2D sg2d) { |
| if (sg2d.paintState <= sg2d.PAINT_ALPHACOLOR && |
| sg2d.compositeState <= sg2d.COMP_ISCOPY) |
| { |
| return solidloops; |
| } |
| return super.getRenderLoops(sg2d); |
| } |
| |
| public GraphicsConfiguration getDeviceConfiguration() { |
| return graphicsConfig; |
| } |
| |
| /** |
| * Initializes the native Ops pointer. |
| */ |
| private native void initOps(int depth, int transparency); |
| |
| /** |
| * This native method creates the offscreen surface in video memory and |
| * (if necessary) initializes DirectDraw |
| */ |
| private native void initSurface(int depth, int width, int height, |
| int screen, |
| boolean isVolatile, |
| int transparency); |
| |
| public native void restoreSurface(); |
| |
| /** |
| * Non-public constructor. Use createData() to create an object. |
| * |
| * This constructor is used to house the common construction |
| * code shared between the creation of Win32OSSD objects |
| * and subclasses of Win32OSSD (such as D3DSurfaceData |
| * and WinBackBufferSurfaceData). |
| * |
| * It calls the common constructor in the parent, and then |
| * initializes other shared Win32 data. |
| */ |
| protected Win32OffScreenSurfaceData(int width, int height, |
| SurfaceType sType, ColorModel cm, |
| GraphicsConfiguration gc, |
| Image image, int transparency) |
| { |
| super(sType, cm); |
| this.width = width; |
| this.height = height; |
| this.graphicsConfig = gc; |
| this.image = image; |
| this.transparency = transparency; |
| this.solidloops = |
| ((Win32GraphicsConfig)graphicsConfig).getSolidLoops(sType); |
| initOps(cm.getPixelSize(), transparency); |
| } |
| |
| /** |
| * Private constructor. Use createData() to create an object. |
| * |
| * This constructor calls the common constructor above and then |
| * performs the specific initialization of the Win32Surface. |
| */ |
| private Win32OffScreenSurfaceData(int width, int height, |
| SurfaceType sType, ColorModel cm, |
| Win32GraphicsConfig gc, |
| Image image, int transparency, |
| int screen) |
| { |
| this(width, height, sType, cm, gc, image, transparency); |
| initSurface(cm.getPixelSize(), width, height, screen, |
| (image instanceof SunVolatileImage), transparency); |
| setBlitProxyKey(gc.getProxyKey()); |
| } |
| |
| /** |
| * Need this since the surface data is created with |
| * the color model of the target GC, which is always |
| * opaque. But in SunGraphics2D.blitSD we choose loops |
| * based on the transparency on the source SD, so |
| * we could choose wrong loop (blit instead of blitbg, |
| * for example, which will cause problems in transparent |
| * case). |
| */ |
| public int getTransparency() { |
| return transparency; |
| } |
| |
| /** |
| * When someone asks for a new surface data, we punt to our |
| * container image which will attempt to restore the contents |
| * of this surface or, failing that, will return null. |
| */ |
| public SurfaceData getReplacement() { |
| return restoreContents(image); |
| } |
| |
| public Rectangle getBounds() { |
| return new Rectangle(width, height); |
| } |
| |
| protected native void nativeInvalidate(); |
| |
| public void invalidate() { |
| if (isValid()) { |
| synchronized (this) { |
| wrn = null; |
| } |
| nativeInvalidate(); |
| super.invalidate(); |
| } |
| } |
| |
| public native void setTransparentPixel(int pixel); |
| |
| public native void flush(); |
| |
| /** |
| * Returns true if the native representation of this image has been |
| * moved into ddraw system memory. This happens when many reads |
| * or read-modify-write operations are requested of that surface. |
| * If we have moved that surface into system memory, we should note that |
| * here so that someone wanting to copy something to this surface will |
| * take that into account during that copy. |
| */ |
| public boolean surfacePunted() { |
| return ddSurfacePunted; |
| } |
| |
| protected void markSurfaceLost() { |
| synchronized (this) { |
| wrn = null; |
| } |
| setSurfaceLost(true); |
| if (image != null) { |
| // Inform the Volatile that it lost its accelerated surface |
| SurfaceManager sMgr = SurfaceManager.getManager(image); |
| sMgr.acceleratedSurfaceLost(); |
| } |
| } |
| |
| /** |
| * This method is called from the native code if an unrecoverable |
| * error has been detected. |
| * |
| * Marks the surface lost, and notifies the surface manager |
| * that the DirectDraw acceleration for the corresponding image |
| * should be disabled. |
| */ |
| protected void disableDD() { |
| markSurfaceLost(); |
| if (image != null) { |
| SurfaceManager sMgr = SurfaceManager.getManager(image); |
| // REMIND: yes, this is not pretty; the accelerationEnabled property |
| // should be pulled up to SurfaceManager some day. |
| if (sMgr instanceof WinVolatileSurfaceManager) { |
| ((WinVolatileSurfaceManager)sMgr).setAccelerationEnabled(false); |
| } |
| } |
| setBlitProxyKey(null); |
| } |
| |
| /** |
| * Returns destination Image associated with this SurfaceData. |
| */ |
| public Object getDestination() { |
| return image; |
| } |
| |
| @Override |
| public boolean copyArea(SunGraphics2D sg2d, |
| int x, int y, int w, int h, int dx, int dy) |
| { |
| CompositeType comptype = sg2d.imageComp; |
| if (sg2d.transformState < sg2d.TRANSFORM_TRANSLATESCALE && |
| sg2d.clipState != sg2d.CLIP_SHAPE && |
| (CompositeType.SrcOverNoEa.equals(comptype) || |
| CompositeType.SrcNoEa.equals(comptype))) |
| { |
| x += sg2d.transX; |
| y += sg2d.transY; |
| int dstx1 = x + dx; |
| int dsty1 = y + dy; |
| int dstx2 = dstx1 + w; |
| int dsty2 = dsty1 + h; |
| Region clip = sg2d.getCompClip(); |
| if (dstx1 < clip.getLoX()) dstx1 = clip.getLoX(); |
| if (dsty1 < clip.getLoY()) dsty1 = clip.getLoY(); |
| if (dstx2 > clip.getHiX()) dstx2 = clip.getHiX(); |
| if (dsty2 > clip.getHiY()) dsty2 = clip.getHiY(); |
| if (dstx1 < dstx2 && dsty1 < dsty2) { |
| ddPipe.devCopyArea(this, dstx1 - dx, dsty1 - dy, |
| dx, dy, |
| dstx2 - dstx1, dsty2 - dsty1); |
| } |
| return true; |
| } |
| return false; |
| } |
| } |
