/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/**
* This class provides various pieces of information relevant to a
* particular drawing surface. The information obtained from this
* object describes the pixels of a particular instance of a drawing
* surface and can only be shared among the various graphics objects
* that target the same BufferedImage or the same screen Component.
* <p>
* Each SurfaceData object holds a StateTrackableDelegate object
* which tracks both changes to the content of the pixels of this
* surface and changes to the overall state of the pixels - such
* as becoming invalid or losing the surface. The delegate is
* marked "dirty" whenever the setSurfaceLost() or invalidate()
* methods are called and should also be marked "dirty" by the
* rendering pipelines whenever they modify the pixels of this
* SurfaceData.
* <p>
* If you get a StateTracker from a SurfaceData and it reports
* that it is still "current", then you can trust that the pixels
* have not changed and that the SurfaceData is still valid and
* has not lost its underlying storage (surfaceLost) since you
* retrieved the tracker.
*/
public abstract class SurfaceData
{
private long pData;
private boolean valid;
private static native void initIDs();
static {
initIDs();
}
}
}
{
this.stateDelegate = trackable;
this.colorModel = cm;
this.surfaceType = surfaceType;
valid = true;
}
valid = true;
}
/**
* Subclasses can set a "blit proxy key" which will be used
* along with the SurfaceManager.getCacheData() mechanism to
* store acceleration-compatible cached copies of source images.
* This key is a "tag" used to identify which cached copies
* are compatible with this destination SurfaceData.
* The getSourceSurfaceData() method uses this key to manage
* cached copies of a source image as described below.
* <p>
* The Object used as this key should be as unique as it needs
* to be to ensure that multiple acceleratible destinations can
* each store their cached copies separately under different keys
* without interfering with each other or getting back the wrong
* cached copy.
* <p>
* Many acceleratable SurfaceData objects can use their own
* GraphicsConfiguration as their proxy key as the GC object will
* typically be unique to a given screen and pixel format, but
* other rendering destinations may have more or less stringent
* sharing requirements. For instance, X11 pixmaps can be
* shared on a given screen by any GraphicsConfiguration that
* has the same depth and SurfaceType. Multiple such GCs with
* the same depth and SurfaceType can exist per screen so storing
* a different cached proxy for each would be a waste. One can
* imagine platforms where a single cached copy can be created
* and shared across all screens and pixel formats - such
* implementations could use a single heavily shared key Object.
*/
// Caching is effectively disabled if we never have a proxy key
// since the getSourceSurfaceData() method only does caching
// if the key is not null.
if (SurfaceDataProxy.isCachingAllowed()) {
this.blitProxyKey = key;
}
}
/**
* 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>
*/
int txtype,
{
blitProxyKey != null)
{
} else {
}
}
}
return srcData;
}
/**
* This method is called on a destination SurfaceData to choose
* a proper SurfaceDataProxy subclass for a source SurfaceData
* to use to control when and with what surface to override a
* given image operation. The argument is the default SurfaceData
* for the source Image.
* <p>
* The type of the return object is chosen based on the
* acceleration capabilities of this SurfaceData and the
* type of the given source SurfaceData object.
* <p>
* In some cases the original SurfaceData will always be the
* best choice to use to blit to this SurfaceData. This can
* happen if the source image is a hardware surface of the
* same type as this one and so acceleration will happen without
* any caching. It may also be the case that the source image
* can never be accelerated on this SurfaceData - for example
* because it is translucent and there are no accelerated
* translucent image ops for this surface.
* <p>
* In those cases there is a special SurfaceDataProxy.UNCACHED
* instance that represents a NOP for caching purposes - it
* always returns the original sourceSD object as the replacement
* copy so no caching is ever performed.
*/
return SurfaceDataProxy.UNCACHED;
}
/**
* 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.
*/
return sMgr.getPrimarySurfaceData();
}
/**
* Restores the contents of the given Image and then returns the new
* SurfaceData object in use by the Image's SurfaceManager.
*/
return sMgr.restoreContents();
}
return stateDelegate.getState();
}
return stateDelegate.getStateTracker();
}
/**
* Marks this surface as dirty.
*/
public final void markDirty() {
}
/**
* Sets the value of the surfaceLost variable, which indicates whether
* something has happened to the rendering surface such that it needs
* to be restored and re-rendered.
*/
surfaceLost = lost;
}
public boolean isSurfaceLost() {
return surfaceLost;
}
/**
* Returns a boolean indicating whether or not this SurfaceData is valid.
*/
public final boolean isValid() {
return valid;
}
return disposerReferent;
}
public long getNativeOps() {
return pData;
}
/**
* Sets this SurfaceData object to the invalid state. All Graphics
* objects must get a new SurfaceData object via the refresh method
* and revalidate their pipelines before continuing.
*/
public void invalidate() {
valid = false;
}
/**
* Certain changes in the configuration of a surface require the
* invalidation of existing associated SurfaceData objects and
* the creation of brand new ones. These changes include size,
* ColorModel, or SurfaceType. Existing Graphics objects
* which are directed at such surfaces, however, must continue
* to render to them even after the change occurs underneath
* the covers. The getReplacement() method is called from
* SunGraphics2D.revalidateAll() when the associated SurfaceData
* is found to be invalid so that a Graphics object can continue
* to render to the surface in its new configuration.
*
* Such changes only tend to happen to window based surfaces since
* most image based surfaces never change size or pixel format.
* Even VolatileImage objects never change size and they only
* change their pixel format when manually validated against a
* new GraphicsConfiguration, at which point old Graphics objects
* are no longer expected to render to them after the validation
* step. Thus, only window based surfaces really need to deal
* with this form of replacement.
*/
// Utility subclass to add the LoopBasedPipe tagging interface
static class PixelToShapeLoopConverter
extends PixelToShapeConverter
implements LoopBasedPipe
{
super(pipe);
}
}
// Utility subclass to add the LoopBasedPipe tagging interface
static class PixelToPgramLoopConverter
extends PixelToParallelogramConverter
implements LoopBasedPipe
{
double minPenSize,
double normPosition,
boolean adjustfill)
{
}
}
private static PixelToParallelogramConverter
{
return new PixelToParallelogramConverter(renderer,
1.0/8.0, 0.499,
false);
}
private static PixelToParallelogramConverter
{
}
static {
colorPrimitives = new LoopPipe();
outlineTextRenderer = new OutlineTextRenderer();
solidTextRenderer = new SolidTextRenderer();
aaTextRenderer = new AATextRenderer();
lcdTextRenderer = new LCDTextRenderer();
colorPipe = new AlphaColorPipe();
// colorShape = colorPrimitives;
1.0, 0.25, true);
paintPipe = new AlphaPaintPipe();
compPipe = new GeneralCompositePipe();
}
/* Not all surfaces and rendering mode combinations support LCD text. */
int haveLCDLoop;
int havePgramXORLoop;
int havePgramSolidLoop;
// For now the answer can only be true in the following cases:
{
if (haveLCDLoop == LOOP_UNKNOWN) {
getSurfaceType());
}
return haveLCDLoop == LOOP_FOUND;
}
return false; /* for now - in the future we may want to search */
}
if (havePgramXORLoop == LOOP_UNKNOWN) {
getSurfaceType());
}
return havePgramXORLoop == LOOP_FOUND;
{
if (havePgramSolidLoop == LOOP_UNKNOWN) {
getSurfaceType());
}
return havePgramSolidLoop == LOOP_FOUND;
}
}
return false;
}
// REMIND: Ideally custom paint mode would use glyph
// rendering as opposed to outline rendering but the
// glyph paint rendering pipeline uses MaskBlit which
// is not defined for XOR. This means that text drawn
// in XOR mode with a Color object is different than
// text drawn in XOR mode with a Paint object.
} else {
if (canRenderParallelograms(sg2d)) {
// Note that we use the transforming pipe here because it
// will examine the shape and possibly perform an optimized
// operation if it can be simplified. The simplifications
// will be valid for all STROKE and TRANSFORM types.
} else {
}
// REMIND: We should not be changing text strategies
// between outline and glyph rendering based upon the
// presence of a complex clip as that could cause a
// mismatch when drawing the same text both clipped
// and unclipped on two separate rendering passes.
// Unfortunately, all of the clipped glyph rendering
// pipelines rely on the use of the MaskBlit operation
// which is not defined for XOR.
} else {
} else {
} else {
}
}
}
// assert(sg2d.surfaceData == this);
}
} else {
}
} else {
} else {
}
}
// assert(sg2d.surfaceData == this);
} else {
: AAColorViaShape);
{
} else {
}
}
} else {
} else {
}
}
{
// assert(sg2d.surfaceData == this);
} else {
}
} else {
} else {
}
}
} else {
if (canRenderParallelograms(sg2d)) {
// Note that we use the transforming pipe here because it
// will examine the shape and possibly perform an optimized
// operation if it can be simplified. The simplifications
// will be valid for all STROKE and TRANSFORM types.
} else {
}
} else {
} else {
}
}
// assert(sg2d.surfaceData == this);
}
// check for loops
{
}
}
/* Return the text pipe to be used based on the graphics AA hint setting,
* and the rest of the graphics state is compatible with these loops.
* If the text AA hint is "DEFAULT", then the AA graphics hint requests
* the AA text renderer, else it requests the B&W text renderer.
*/
/* Try to avoid calling getFontInfo() unless its needed to
* resolve one of the new AA types.
*/
switch (sg2d.textAntialiasHint) {
if (aaHintIsOn) {
return aaTextRenderer;
} else {
return solidTextRenderer;
}
return solidTextRenderer;
return aaTextRenderer;
default:
return lcdTextRenderer;
return aaTextRenderer;
return solidTextRenderer;
/* This should not be reached as the FontInfo will
* always explicitly set its hint value. So whilst
* this could be collapsed to returning say just
* solidTextRenderer, or even removed, its left
* here in case DEFAULT is ever passed in.
*/
default:
if (aaHintIsOn) {
return aaTextRenderer;
} else {
return solidTextRenderer;
}
}
}
}
switch (sg2d.paintState) {
return SurfaceType.OpaqueColor;
return SurfaceType.AnyColor;
case SunGraphics2D.PAINT_GRADIENT:
return SurfaceType.OpaqueGradientPaint;
} else {
return SurfaceType.GradientPaint;
}
return SurfaceType.OpaqueLinearGradientPaint;
} else {
return SurfaceType.LinearGradientPaint;
}
return SurfaceType.OpaqueRadialGradientPaint;
} else {
return SurfaceType.RadialGradientPaint;
}
case SunGraphics2D.PAINT_TEXTURE:
return SurfaceType.OpaqueTexturePaint;
} else {
return SurfaceType.TexturePaint;
}
default:
case SunGraphics2D.PAINT_CUSTOM:
return SurfaceType.AnyPaint;
}
}
} else {
}
}
return compType;
}
/**
* Returns a MaskFill object that can be used on this destination
* with the source (paint) and composite types determined by the given
* SunGraphics2D, or null if no such MaskFill object can be located.
* Subclasses can override this method if they wish to filter other
* attributes (such as the hardware capabilities of the destination
* surface) before returning a specific MaskFill object.
*/
}
/**
* Return a RenderLoops object containing all of the basic
* GraphicsPrimitive objects for rendering to the destination
* surface with the current attributes of the given SunGraphics2D.
*/
if (o != null) {
return (RenderLoops) o;
}
return loops;
}
/**
* Construct and return a RenderLoops object containing all of
* the basic GraphicsPrimitive objects for rendering to the
* destination surface with the given source, destination, and
* composite types.
*/
{
/*
System.out.println("drawLine: "+loops.drawLineLoop);
System.out.println("fillRect: "+loops.fillRectLoop);
System.out.println("drawRect: "+loops.drawRectLoop);
System.out.println("drawPolygons: "+loops.drawPolygonsLoop);
System.out.println("fillSpans: "+loops.fillSpansLoop);
System.out.println("drawGlyphList: "+loops.drawGlyphListLoop);
System.out.println("drawGlyphListAA: "+loops.drawGlyphListAALoop);
System.out.println("drawGlyphListLCD: "+loops.drawGlyphListLCDLoop);
*/
return loops;
}
/**
* Return the GraphicsConfiguration object that describes this
* destination surface.
*/
/**
* Return the SurfaceType object that describes the destination
* surface.
*/
return surfaceType;
}
/**
* Return the ColorModel for the destination surface.
*/
return colorModel;
}
/**
* Returns the type of this <code>Transparency</code>.
* @return the field type of this <code>Transparency</code>, which is
* either OPAQUE, BITMASK or TRANSLUCENT.
*/
public int getTransparency() {
return getColorModel().getTransparency();
}
/**
* Return a readable Raster which contains the pixels for the
* specified rectangular region of the destination surface.
* The coordinate origin of the returned Raster is the same as
* the device space origin of the destination surface.
* In some cases the returned Raster might also be writeable.
* In most cases, the returned Raster might contain more pixels
* than requested.
*
* @see useTightBBoxes
*/
/**
* Does the pixel accessibility of the destination surface
* suggest that rendering algorithms might want to take
* extra time to calculate a more accurate bounding box for
* the operation being performed?
* The typical case when this will be true is when a copy of
* the pixels has to be made when doing a getRaster. The
* fewer pixels copied, the faster the operation will go.
*
* @see getRaster
*/
public boolean useTightBBoxes() {
// Note: The native equivalent would trigger on VISIBLE_TO_NATIVE
// REMIND: This is not used - should be obsoleted maybe
return true;
}
/**
* Returns the pixel data for the specified Argb value packed
* into an integer for easy storage and conveyance.
*/
}
/**
* Returns the pixel data for the specified color packed into an
* integer for easy storage and conveyance.
*
* This method will use the getRGB() method of the Color object
* and defer to the pixelFor(int rgb) method if not overridden.
*
* For now this is a convenience function, but for cases where
* the highest quality color conversion is requested, this method
* should be overridden in those cases so that a more direct
* conversion of the color to the destination color space
* can be done using the additional information in the Color
* object.
*/
}
/**
* Returns the Argb representation for the specified integer value
* which is packed in the format of the associated ColorModel.
*/
}
/**
* Returns the bounds of the destination surface.
*/
/**
* Performs Security Permissions checks to see if a Custom
* Composite object should be allowed access to the pixels
* of this surface.
*/
protected void checkCustomComposite() {
if (compPermission == null) {
}
}
}
/**
* Fetches private field IndexColorModel.allgrayopaque
* which is true when all palette entries in the color
* model are gray and opaque.
*/
/**
* For our purposes null and NullSurfaceData are the same as
* they represent a disposed surface.
*/
return true;
}
return false;
}
/**
* Performs a copyarea within this surface. Returns
* false if there is no algorithm to perform the copyarea
* given the current settings of the SunGraphics2D.
*/
{
return false;
}
/**
* Synchronously releases resources associated with this surface.
*/
public void flush() {}
/**
* Returns destination associated with this SurfaceData. This could be
* either an Image or a Component; subclasses of SurfaceData are
* responsible for returning the appropriate object.
*/
/**
* Returns default scale factor of the destination surface. Scale factor
* describes the mapping between virtual and physical coordinates of the
* SurfaceData. If the scale is 2 then virtual pixel coordinates need to be
* doubled for physical pixels.
*/
public int getDefaultScale() {
return 1;
}
}