Java SurfaceManager.getManager方法代码示例

import sun.awt.image.SurfaceManager; //导入方法依赖的package包/类
/**
 * If acceleration should no longer be used for this surface.
 * This implementation flags to the manager that it should no
 * longer attempt to re-create a D3DSurface.
 */
void disableAccelerationForSurface() {
    if (offscreenImage != null) {
        SurfaceManager sm = SurfaceManager.getManager(offscreenImage);
        if (sm instanceof D3DVolatileSurfaceManager) {
            setSurfaceLost(true);
            ((D3DVolatileSurfaceManager)sm).setAccelerationEnabled(false);
        }
    }
}
 

import sun.awt.image.SurfaceManager; //导入方法依赖的package包/类
/**
 * We need to let the surface manager know that the surface is lost so
 * that for example BufferStrategy.contentsLost() returns correct result.
 * Normally the status of contentsLost is set in validate(), but in some
 * cases (like Swing's buffer per window) we intentionally don't call
 * validate from the toolkit thread but only check for the BS status.
 */
@Override
public void setSurfaceLost(boolean lost) {
    super.setSurfaceLost(lost);
    if (lost && offscreenImage != null) {
        SurfaceManager sm = SurfaceManager.getManager(offscreenImage);
        sm.acceleratedSurfaceLost();
    }
}
 

import sun.awt.image.SurfaceManager; //导入方法依赖的package包/类
/**
 * If the destination surface's peer can potentially handle accelerated
 * on-screen rendering then it is likely that the condition which resulted
 * in VI to Screen operation is temporary, so this method sets the
 * restore countdown in hope that the on-screen accelerated rendering will
 * resume. In the meantime the backup surface of the VISM will be used.
 *
 * The countdown is needed because otherwise we may never break out
 * of "do { vi.validate()..} while(vi.lost)" loop since validate() could
 * restore the source surface every time and it will get lost again on the
 * next copy attempt, and we would never get a chance to use the backup
 * surface. By using the countdown we allow the backup surface to be used
 * while the screen surface gets sorted out, or if it for some reason can
 * never be restored.
 *
 * If the destination surface's peer could never do accelerated onscreen
 * rendering then the acceleration for the SurfaceManager associated with
 * the source surface is disabled forever.
 */
static void handleVItoScreenOp(SurfaceData src, SurfaceData dst) {
    if (src instanceof D3DSurfaceData &&
        dst instanceof GDIWindowSurfaceData)
    {
        D3DSurfaceData d3dsd = (D3DSurfaceData)src;
        SurfaceManager mgr =
            SurfaceManager.getManager((Image)d3dsd.getDestination());
        if (mgr instanceof D3DVolatileSurfaceManager) {
            D3DVolatileSurfaceManager vsm = (D3DVolatileSurfaceManager)mgr;
            if (vsm != null) {
                d3dsd.setSurfaceLost(true);

                GDIWindowSurfaceData wsd = (GDIWindowSurfaceData)dst;
                WComponentPeer p = wsd.getPeer();
                if (D3DScreenUpdateManager.canUseD3DOnScreen(p,
                        (Win32GraphicsConfig)p.getGraphicsConfiguration(),
                        p.getBackBuffersNum()))
                {
                    // 10 is only chosen to be greater than the number of
                    // times a sane person would call validate() inside
                    // a validation loop, and to reduce thrashing between
                    // accelerated and backup surfaces
                    vsm.setRestoreCountdown(10);
                } else {
                    vsm.setAccelerationEnabled(false);
                }
            }
        }
    }
}
 

import sun.awt.image.SurfaceManager; //导入方法依赖的package包/类
/**
 * This method is called on a destination SurfaceData to choose
 * the best SurfaceData from a source Image for an imaging
 * operation, with help from its SurfaceManager.
 * The method may determine that the default SurfaceData was
 * really the best choice in the first place, or it may decide
 * to use a cached surface.  Some general decisions about whether
 * acceleration is enabled are made by this method, but any
 * decision based on the type of the source image is made in
 * the makeProxyFor method below when it comes up with the
 * appropriate SurfaceDataProxy instance.
 * The parameters describe the type of imaging operation being performed.
 * <p>
 * If a blitProxyKey was supplied by the subclass then it is
 * used to potentially override the choice of source SurfaceData.
 * The outline of this process is:
 * <ol>
 * <li> Image pipeline asks destSD to find an appropriate
 *      srcSD for a given source Image object.
 * <li> destSD gets the SurfaceManager of the source Image
 *      and first retrieves the default SD from it using
 *      getPrimarySurfaceData()
 * <li> destSD uses its "blit proxy key" (if set) to look for
 *      some cached data stored in the source SurfaceManager
 * <li> If the cached data is null then makeProxyFor() is used
 *      to create some cached data which is stored back in the
 *      source SurfaceManager under the same key for future uses.
 * <li> The cached data will be a SurfaceDataProxy object.
 * <li> The SurfaceDataProxy object is then consulted to
 *      return a replacement SurfaceData object (typically
 *      a cached copy if appropriate, or the original if not).
 * </ol>
 */
public SurfaceData getSourceSurfaceData(Image img,
                                        int txtype,
                                        CompositeType comp,
                                        Color bgColor)
{
    SurfaceManager srcMgr = SurfaceManager.getManager(img);
    SurfaceData srcData = srcMgr.getPrimarySurfaceData();
    if (img.getAccelerationPriority() > 0.0f &&
        blitProxyKey != null)
    {
        SurfaceDataProxy sdp =
            (SurfaceDataProxy) srcMgr.getCacheData(blitProxyKey);
        if (sdp == null || !sdp.isValid()) {
            if (srcData.getState() == State.UNTRACKABLE) {
                sdp = SurfaceDataProxy.UNCACHED;
            } else {
                sdp = makeProxyFor(srcData);
            }
            srcMgr.setCacheData(blitProxyKey, sdp);
        }
        srcData = sdp.replaceData(srcData, txtype, comp, bgColor);
    }
    return srcData;
}
 

import sun.awt.image.SurfaceManager; //导入方法依赖的package包/类
/**
 * Restores the contents of the given Image and then returns the new
 * SurfaceData object in use by the Image's SurfaceManager.
 */
public static SurfaceData restoreContents(Image img) {
    SurfaceManager sMgr = SurfaceManager.getManager(img);
    return sMgr.restoreContents();
}
 

import sun.awt.image.SurfaceManager; //导入方法依赖的package包/类
/**
 * Performs the native OGL flip operation for the given target Component.
 */
@Override
public void flip(CPlatformView pView,
                 Component target, VolatileImage xBackBuffer,
                 int x1, int y1, int x2, int y2,
                 BufferCapabilities.FlipContents flipAction)
{
    if (flipAction == BufferCapabilities.FlipContents.COPIED) {
        SurfaceManager vsm = SurfaceManager.getManager(xBackBuffer);
        SurfaceData sd = vsm.getPrimarySurfaceData();

        if (sd instanceof CGLVSyncOffScreenSurfaceData) {
            CGLVSyncOffScreenSurfaceData vsd =
                (CGLVSyncOffScreenSurfaceData)sd;
            SurfaceData bbsd = vsd.getFlipSurface();
            Graphics2D bbg =
                new SunGraphics2D(bbsd, Color.black, Color.white, null);
            try {
                bbg.drawImage(xBackBuffer, 0, 0, null);
            } finally {
                bbg.dispose();
            }
        } else {
            pView.drawImageOnPeer(xBackBuffer, x1, y1, x2, y2);
            return;
        }
    } else if (flipAction == BufferCapabilities.FlipContents.PRIOR) {
        // not supported by CGL...
        return;
    }

    OGLSurfaceData.swapBuffers(pView.getAWTView());

    if (flipAction == BufferCapabilities.FlipContents.BACKGROUND) {
        Graphics g = xBackBuffer.getGraphics();
        try {
            g.setColor(target.getBackground());
            g.fillRect(0, 0,
                       xBackBuffer.getWidth(),
                       xBackBuffer.getHeight());
        } finally {
            g.dispose();
        }
    }
}
 

import sun.awt.image.SurfaceManager; //导入方法依赖的package包/类
/**
 * Extracts the SurfaceManager from the given Image, and then
 * returns the SurfaceData object that would best be suited as the
 * destination surface in some rendering operation.
 */
public static SurfaceData getPrimarySurfaceData(Image img) {
    SurfaceManager sMgr = SurfaceManager.getManager(img);
    return sMgr.getPrimarySurfaceData();
}