/** * 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(); } }
/** Performs the native GLX flip operation for the given target Component. */ @Override public void flip( X11ComponentPeer peer, 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 GLXVSyncOffScreenSurfaceData) { GLXVSyncOffScreenSurfaceData vsd = (GLXVSyncOffScreenSurfaceData) 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 { Graphics g = peer.getGraphics(); try { g.drawImage(xBackBuffer, x1, y1, x2, y2, x1, y1, x2, y2, null); } finally { g.dispose(); } return; } } else if (flipAction == BufferCapabilities.FlipContents.PRIOR) { // not supported by GLX... return; } OGLSurfaceData.swapBuffers(peer.getContentWindow()); 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(); } } }
/** * 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); } } }
/** * 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; }
/** * 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(); }
/** * 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(); }