Java D3DWindowSurfaceData.isSurfaceLost方法代码示例

import sun.java2d.d3d.D3DSurfaceData.D3DWindowSurfaceData; //导入方法依赖的package包/类
/**
 * Restores the passed surface if it was lost, resets the lost status.
 * @param sd surface to be validated
 * @return true if surface wasn't lost or if restoration was successful,
 * false otherwise
 */
private boolean validate(D3DWindowSurfaceData sd) {
    if (sd.isSurfaceLost()) {
        try {
            sd.restoreSurface();
            // if succeeded, first fill the surface with bg color
            // note: use the non-synch method to avoid incorrect lock order
            Color bg = sd.getPeer().getBackgroundNoSync();
            SunGraphics2D sg2d = new SunGraphics2D(sd, bg, bg, null);
            sg2d.fillRect(0, 0, sd.getBounds().width, sd.getBounds().height);
            sg2d.dispose();
            // now clean the dirty status so that we don't flip it
            // next time before it gets repainted; it is safe
            // to do without the lock because we will issue a
            // repaint anyway so we will not lose any rendering
            sd.markClean();
            // since the surface was successfully restored we need to
            // repaint whole window to repopulate the back-buffer
            repaintPeerTarget(sd.getPeer());
        } catch (InvalidPipeException ipe) {
            return false;
        }
    }
    return true;
}
 

import sun.java2d.d3d.D3DSurfaceData.D3DWindowSurfaceData; //导入方法依赖的package包/类
/**
 * Creates a graphics object for the passed in surface data. If
 * the surface is lost, it is restored.
 * If the surface wasn't lost or the restoration was successful
 * the surface is added to the list of maintained surfaces
 * (if it hasn't been already).
 *
 * If the updater thread hasn't been created yet , it will be created and
 * started.
 *
 * @param sd surface data for which to create SunGraphics2D
 * @param peer peer associated with the surface data
 * @param fgColor fg color to be used in graphics
 * @param bgColor bg color to be used in graphics
 * @param font font to be used in graphics
 * @return a SunGraphics2D object for the surface (or for temp GDI
 * surface data)
 */
@Override
public Graphics2D createGraphics(SurfaceData sd,
        WComponentPeer peer, Color fgColor, Color bgColor, Font font)
{
    if (!done && sd instanceof D3DWindowSurfaceData) {
        D3DWindowSurfaceData d3dw = (D3DWindowSurfaceData)sd;
        if (!d3dw.isSurfaceLost() || validate(d3dw)) {
            trackScreenSurface(d3dw);
            return new SunGraphics2D(sd, fgColor, bgColor, font);
        }
        // could not restore the d3dw surface, use the cached gdi surface
        // instead for this graphics object; note that we do not track
        // this new gdi surface, it is only used for this graphics
        // object
        sd = getGdiSurface(d3dw);
    }
    return super.createGraphics(sd, peer, fgColor, bgColor, font);
}
 

import sun.java2d.d3d.D3DSurfaceData.D3DWindowSurfaceData; //导入方法依赖的package包/类
public void run() {
    while (!done) {
        synchronized (runLock) {
            // If the list is empty, suspend the thread until a
            // new surface is added. Note that we have to check before
            // wait() (and inside the runLock), otherwise we could miss a
            // notify() when a new surface is added and sleep forever.
            long timeout = d3dwSurfaces.size() > 0 ? 100 : 0;

            // don't go to sleep if there's a thread waiting for an update
            if (!needsUpdateNow) {
                try { runLock.wait(timeout); }
                    catch (InterruptedException e) {}
            }
            // if we were woken up, there are probably surfaces in the list,
            // no need to check if the list is empty
        }

        // make a copy to avoid synchronization during the loop
        D3DWindowSurfaceData surfaces[] = new D3DWindowSurfaceData[] {};
        synchronized (this) {
            surfaces = d3dwSurfaces.toArray(surfaces);
        }
        for (D3DWindowSurfaceData sd : surfaces) {
            // skip invalid surfaces (they could have become invalid
            // after we made a copy of the list) - just a precaution
            if (sd.isValid() && (sd.isDirty() || sd.isSurfaceLost())) {
                if (!sd.isSurfaceLost()) {
                    // the flip and the clearing of the dirty state
                    // must be done under the lock, otherwise it's
                    // possible to miss an update to the surface
                    D3DRenderQueue rq = D3DRenderQueue.getInstance();
                    rq.lock();
                    try {
                        Rectangle r = sd.getBounds();
                        D3DSurfaceData.swapBuffers(sd, 0, 0,
                                                   r.width, r.height);
                        sd.markClean();
                    } finally {
                        rq.unlock();
                    }
                } else if (!validate(sd)) {
                    // it is possible that the validation may never
                    // succeed, we need to detect this and replace
                    // the d3dw surface with gdi; the replacement of
                    // the surface will also trigger a repaint
                    sd.getPeer().replaceSurfaceDataLater();
                }
            }
        }
        synchronized (runLock) {
            needsUpdateNow = false;
            runLock.notifyAll();
        }
    }
}