sun.java2d.loops.CompositeType Java Examples

protected boolean scaleSurfaceData(SunGraphics2D sg,
                                   Region clipRegion,
                                   SurfaceData srcData,
                                   SurfaceData dstData,
                                   SurfaceType srcType,
                                   SurfaceType dstType,
                                   int sx1, int sy1,
                                   int sx2, int sy2,
                                   double dx1, double dy1,
                                   double dx2, double dy2)
{
    CompositeType comp = sg.imageComp;
    if (CompositeType.SrcOverNoEa.equals(comp) &&
        (srcData.getTransparency() == Transparency.OPAQUE))
    {
        comp = CompositeType.SrcNoEa;
    }

    ScaledBlit blit = ScaledBlit.getFromCache(srcType, comp, dstType);
    if (blit != null) {
        blit.Scale(srcData, dstData, sg.composite, clipRegion,
                   sx1, sy1, sx2, sy2, dx1, dy1, dx2, dy2);
        return true;
    }
    return false;
}
 

public static synchronized RenderLoops getSolidLoops(SurfaceType type) {
    for (int i = CACHE_SIZE - 1; i >= 0; i--) {
        SurfaceType t = typecache[i];
        if (t == type) {
            return loopcache[i];
        } else if (t == null) {
            break;
        }
    }
    RenderLoops l = makeRenderLoops(SurfaceType.OpaqueColor,
                                    CompositeType.SrcNoEa,
                                    type);
    System.arraycopy(loopcache, 1, loopcache, 0, CACHE_SIZE-1);
    System.arraycopy(typecache, 1, typecache, 0, CACHE_SIZE-1);
    loopcache[CACHE_SIZE - 1] = l;
    typecache[CACHE_SIZE - 1] = type;
    return l;
}
 

public static synchronized RenderLoops getSolidLoops(SurfaceType type) {
    for (int i = CACHE_SIZE - 1; i >= 0; i--) {
        SurfaceType t = typecache[i];
        if (t == type) {
            return loopcache[i];
        } else if (t == null) {
            break;
        }
    }
    RenderLoops l = makeRenderLoops(SurfaceType.OpaqueColor,
                                    CompositeType.SrcNoEa,
                                    type);
    System.arraycopy(loopcache, 1, loopcache, 0, CACHE_SIZE-1);
    System.arraycopy(typecache, 1, typecache, 0, CACHE_SIZE-1);
    loopcache[CACHE_SIZE - 1] = l;
    typecache[CACHE_SIZE - 1] = type;
    return l;
}
 

@Override
public synchronized void Transform(SurfaceData src, SurfaceData dst,
                                   Composite comp, Region clip,
                                   AffineTransform at, int hint, int srcx,
                                   int srcy, int dstx, int dsty, int width,
                                   int height){
    Blit convertsrc = Blit.getFromCache(src.getSurfaceType(),
                                        CompositeType.SrcNoEa,
                                        SurfaceType.IntArgbPre);
    // use cached intermediate surface, if available
    final SurfaceData cachedSrc = srcTmp != null ? srcTmp.get() : null;
    // convert source to IntArgbPre
    src = convertFrom(convertsrc, src, srcx, srcy, width, height, cachedSrc,
                      BufferedImage.TYPE_INT_ARGB_PRE);

    // transform IntArgbPre intermediate surface to D3D surface
    performop.Transform(src, dst, comp, clip, at, hint, 0, 0, dstx, dsty,
                        width, height);

    if (src != cachedSrc) {
        // cache the intermediate surface
        srcTmp = new WeakReference<>(src);
    }
}
 

/**
 * This is the default implementation for updating the cached
 * SurfaceData from the source (primary) SurfaceData.
 * A simple Blit is used to copy the pixels from the source to
 * the destination SurfaceData.
 * A subclass can override this implementation if a more complex
 * operation is required to update its cached copies.
 */
public void updateSurfaceData(SurfaceData srcData,
                              SurfaceData dstData,
                              int w, int h)
{
    SurfaceType srcType = srcData.getSurfaceType();
    SurfaceType dstType = dstData.getSurfaceType();
    Blit blit = Blit.getFromCache(srcType,
                                  CompositeType.SrcNoEa,
                                  dstType);
    blit.Blit(srcData, dstData,
              AlphaComposite.Src, null,
              0, 0, 0, 0, w, h);
    dstData.markDirty();
}
 

@Override
public boolean isSupportedOperation(SurfaceData srcData,
                                    int txtype,
                                    CompositeType comp,
                                    Color bgColor)
{
    return false;
}
 

/**
 * This constructor sets mask for this primitive which can be
 * retrieved in native code to set the appropriate values for GDI.
 */
public GDIBlitLoops(SurfaceType srcType, SurfaceType dstType,
                    int rmask, int gmask, int bmask)
{
    super(srcType, CompositeType.SrcNoEa, dstType);
    this.rmask = rmask;
    this.gmask = gmask;
    this.bmask = bmask;
}
 

/**
 * 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.
 */
public RenderLoops getRenderLoops(SunGraphics2D sg2d) {
    SurfaceType src = getPaintSurfaceType(sg2d);
    CompositeType comp = getFillCompositeType(sg2d);
    SurfaceType dst = sg2d.getSurfaceData().getSurfaceType();

    Object o = loopcache.get(src, comp, dst);
    if (o != null) {
        return (RenderLoops) o;
    }

    RenderLoops loops = makeRenderLoops(src, comp, dst);
    loopcache.put(src, comp, dst, loops);
    return loops;
}
 

@Override
public boolean isSupportedOperation(SurfaceData srcData,
                                    int txtype,
                                    CompositeType comp,
                                    Color bgColor)
{
    return false;
}
 

@Override
public boolean isSupportedOperation(SurfaceData srcData,
                                    int txtype,
                                    CompositeType comp,
                                    Color bgColor)
{
    return (bgColor == null || transparency == Transparency.OPAQUE);
}
 

private static CompositeType getFillCompositeType(SunGraphics2D sg2d) {
    CompositeType compType = sg2d.imageComp;
    if (sg2d.compositeState == SunGraphics2D.COMP_ISCOPY) {
        if (compType == CompositeType.SrcOverNoEa) {
            compType = CompositeType.OpaqueSrcOverNoEa;
        } else {
            compType = CompositeType.SrcNoEa;
        }
    }
    return compType;
}
 

public synchronized RenderLoops getSolidLoops(SurfaceType stype) {
    if (solidloops == null || sTypeOrig != stype) {
        solidloops = SurfaceData.makeRenderLoops(SurfaceType.OpaqueColor,
                                                 CompositeType.SrcNoEa,
                                                 stype);
        sTypeOrig = stype;
    }
    return solidloops;
}
 

@Override
public boolean isSupportedOperation(SurfaceData srcData,
                                    int txtype,
                                    CompositeType comp,
                                    Color bgColor)
{
    return false;
}
 

@Override
public boolean isSupportedOperation(SurfaceData srcData,
                                    int txtype,
                                    CompositeType comp,
                                    Color bgColor)
{
    // These could probably be combined into a single
    // nested if, but the logic is easier to follow this way.

    // we don't have X11 scale loops, so always use
    // software surface in case of scaling
    if (txtype >= SunGraphics2D.TRANSFORM_TRANSLATESCALE) {
        return false;
    }

    if (bgColor != null &&
        bgColor.getTransparency() != Transparency.OPAQUE)
    {
        return false;
    }

    // for transparent images SrcNoEa+bgColor has the
    // same effect as SrcOverNoEa+bgColor, so we allow
    // copying from pixmap SD using accelerated blitbg loops:
    // SrcOver will be changed to SrcNoEa in DrawImage.blitSD
    if (CompositeType.SrcOverNoEa.equals(comp) ||
        (CompositeType.SrcNoEa.equals(comp) &&
         bgColor != null))
    {
        return true;
    }

    return false;
}
 

/**
 * Sets the Paint in the current graphics state.
 * @param paint The Paint object to be used to generate color in
 * the rendering process.
 * @see java.awt.Graphics#setColor
 * @see GradientPaint
 * @see TexturePaint
 */
public void setPaint(Paint paint) {
    if (paint instanceof Color) {
        setColor((Color) paint);
        return;
    }
    if (paint == null || this.paint == paint) {
        return;
    }
    this.paint = paint;
    if (imageComp == CompositeType.SrcOverNoEa) {
        // special case where compState depends on opacity of paint
        if (paint.getTransparency() == Transparency.OPAQUE) {
            if (compositeState != COMP_ISCOPY) {
                compositeState = COMP_ISCOPY;
            }
        } else {
            if (compositeState == COMP_ISCOPY) {
                compositeState = COMP_ALPHA;
            }
        }
    }
    Class<? extends Paint> paintClass = paint.getClass();
    if (paintClass == GradientPaint.class) {
        paintState = PAINT_GRADIENT;
    } else if (paintClass == LinearGradientPaint.class) {
        paintState = PAINT_LIN_GRADIENT;
    } else if (paintClass == RadialGradientPaint.class) {
        paintState = PAINT_RAD_GRADIENT;
    } else if (paintClass == TexturePaint.class) {
        paintState = PAINT_TEXTURE;
    } else {
        paintState = PAINT_CUSTOM;
    }
    validFontInfo = false;
    invalidatePipe();
}
 

/**
 * This constructor sets mask for this primitive which can be
 * retrieved in native code to set the appropriate values for GDI.
 */
public GDIBlitLoops(SurfaceType srcType, SurfaceType dstType,
                    int rmask, int gmask, int bmask)
{
    super(srcType, CompositeType.SrcNoEa, dstType);
    this.rmask = rmask;
    this.gmask = gmask;
    this.bmask = bmask;
}
 

public void Blit(SurfaceData src, SurfaceData dst,
                 Composite comp, Region clip,
                 int sx, int sy, int dx, int dy, int w, int h)
{
    Blit blit = Blit.getFromCache(src.getSurfaceType(),
                                  CompositeType.SrcNoEa,
                                  dstType);
    blit.Blit(src, dst, comp, clip, sx, sy, dx, dy, w, h);
    updateBitmask(src, dst,
                  src.getColorModel() instanceof IndexColorModel);
}
 

public void setColor(Color color) {
    if (color == null || color == paint) {
        return;
    }
    this.paint = foregroundColor = color;
    validateColor();
    if ((eargb >> 24) == -1) {
        if (paintState == PAINT_OPAQUECOLOR) {
            return;
        }
        paintState = PAINT_OPAQUECOLOR;
        if (imageComp == CompositeType.SrcOverNoEa) {
            // special case where compState depends on opacity of paint
            compositeState = COMP_ISCOPY;
        }
    } else {
        if (paintState == PAINT_ALPHACOLOR) {
            return;
        }
        paintState = PAINT_ALPHACOLOR;
        if (imageComp == CompositeType.SrcOverNoEa) {
            // special case where compState depends on opacity of paint
            compositeState = COMP_ALPHA;
        }
    }
    validFontInfo = false;
    invalidatePipe();
}
 

public SunCompositeContext(AlphaComposite ac,
                           ColorModel s, ColorModel d)
{
    if (s == null) {
        throw new NullPointerException("Source color model cannot be null");
    }
    if (d == null) {
        throw new NullPointerException("Destination color model cannot be null");
    }
    srcCM = s;
    dstCM = d;
    this.composite = ac;
    this.comptype = CompositeType.forAlphaComposite(ac);
}
 

public SunGraphics2D(SurfaceData sd, Color fg, Color bg, Font f) {
    surfaceData = sd;
    foregroundColor = fg;
    backgroundColor = bg;

    transform = new AffineTransform();
    stroke = defaultStroke;
    composite = defaultComposite;
    paint = foregroundColor;

    imageComp = CompositeType.SrcOverNoEa;

    renderHint = SunHints.INTVAL_RENDER_DEFAULT;
    antialiasHint = SunHints.INTVAL_ANTIALIAS_OFF;
    textAntialiasHint = SunHints.INTVAL_TEXT_ANTIALIAS_DEFAULT;
    fractionalMetricsHint = SunHints.INTVAL_FRACTIONALMETRICS_OFF;
    lcdTextContrast = lcdTextContrastDefaultValue;
    interpolationHint = -1;
    strokeHint = SunHints.INTVAL_STROKE_DEFAULT;
    resolutionVariantHint = SunHints.INTVAL_RESOLUTION_VARIANT_DEFAULT;

    interpolationType = AffineTransformOp.TYPE_NEAREST_NEIGHBOR;

    validateColor();

    devScale = sd.getDefaultScale();
    if (devScale != 1) {
        transform.setToScale(devScale, devScale);
        invalidateTransform();
    }

    font = f;
    if (font == null) {
        font = defaultFont;
    }

    setDevClip(sd.getBounds());
    invalidatePipe();
}
 

/**
 * This is the default implementation for updating the cached
 * SurfaceData from the source (primary) SurfaceData.
 * A simple Blit is used to copy the pixels from the source to
 * the destination SurfaceData.
 * A subclass can override this implementation if a more complex
 * operation is required to update its cached copies.
 */
public void updateSurfaceData(SurfaceData srcData,
                              SurfaceData dstData,
                              int w, int h)
{
    SurfaceType srcType = srcData.getSurfaceType();
    SurfaceType dstType = dstData.getSurfaceType();
    Blit blit = Blit.getFromCache(srcType,
                                  CompositeType.SrcNoEa,
                                  dstType);
    blit.Blit(srcData, dstData,
              AlphaComposite.Src, null,
              0, 0, 0, 0, w, h);
    dstData.markDirty();
}
 

/**
 * This is an alternate implementation for updating the cached
 * SurfaceData from the source (primary) SurfaceData using a
 * background color for transparent pixels.
 * A simple BlitBg is used to copy the pixels from the source to
 * the destination SurfaceData with the specified bgColor.
 * A subclass can override the normal updateSurfaceData method
 * and call this implementation instead if it wants to use color
 * keying for bitmask images.
 */
public void updateSurfaceDataBg(SurfaceData srcData,
                                SurfaceData dstData,
                                int w, int h, Color bgColor)
{
    SurfaceType srcType = srcData.getSurfaceType();
    SurfaceType dstType = dstData.getSurfaceType();
    BlitBg blitbg = BlitBg.getFromCache(srcType,
                                        CompositeType.SrcNoEa,
                                        dstType);
    blitbg.BlitBg(srcData, dstData,
                  AlphaComposite.Src, null, bgColor.getRGB(),
                  0, 0, 0, 0, w, h);
    dstData.markDirty();
}
 

/**
 * This is an alternate implementation for updating the cached
 * SurfaceData from the source (primary) SurfaceData using a
 * background color for transparent pixels.
 * A simple BlitBg is used to copy the pixels from the source to
 * the destination SurfaceData with the specified bgColor.
 * A subclass can override the normal updateSurfaceData method
 * and call this implementation instead if it wants to use color
 * keying for bitmask images.
 */
public void updateSurfaceDataBg(SurfaceData srcData,
                                SurfaceData dstData,
                                int w, int h, Color bgColor)
{
    SurfaceType srcType = srcData.getSurfaceType();
    SurfaceType dstType = dstData.getSurfaceType();
    BlitBg blitbg = BlitBg.getFromCache(srcType,
                                        CompositeType.SrcNoEa,
                                        dstType);
    blitbg.BlitBg(srcData, dstData,
                  AlphaComposite.Src, null, bgColor.getRGB(),
                  0, 0, 0, 0, w, h);
    dstData.markDirty();
}
 

@Override
public boolean isSupportedOperation(SurfaceData srcData,
                                    int txtype,
                                    CompositeType comp,
                                    Color bgColor)
{
    // These could probably be combined into a single
    // nested if, but the logic is easier to follow this way.

    // we don't have X11 scale loops, so always use
    // software surface in case of scaling
    if (txtype >= SunGraphics2D.TRANSFORM_TRANSLATESCALE) {
        return false;
    }

    if (bgColor != null &&
        bgColor.getTransparency() != Transparency.OPAQUE)
    {
        return false;
    }

    // for transparent images SrcNoEa+bgColor has the
    // same effect as SrcOverNoEa+bgColor, so we allow
    // copying from pixmap SD using accelerated blitbg loops:
    // SrcOver will be changed to SrcNoEa in DrawImage.blitSD
    if (CompositeType.SrcOverNoEa.equals(comp) ||
        (CompositeType.SrcNoEa.equals(comp) &&
         bgColor != null))
    {
        return true;
    }

    return false;
}
 

public SunCompositeContext(XORComposite xc,
                           ColorModel s, ColorModel d)
{
    if (s == null) {
        throw new NullPointerException("Source color model cannot be null");
    }
    if (d == null) {
        throw new NullPointerException("Destination color model cannot be null");
    }
    srcCM = s;
    dstCM = d;
    this.composite = xc;
    this.comptype = CompositeType.Xor;
}
 

OGLAnyCompositeBlit(SurfaceType srctype, Blit convertsrc, Blit convertdst,
                    Blit convertresult) {
    super(srctype, CompositeType.Any, OGLSurfaceData.OpenGLSurface);
    this.convertsrc = convertsrc;
    this.convertdst = convertdst;
    this.convertresult = convertresult;
}
 

public SunCompositeContext(AlphaComposite ac,
                           ColorModel s, ColorModel d)
{
    if (s == null) {
        throw new NullPointerException("Source color model cannot be null");
    }
    if (d == null) {
        throw new NullPointerException("Destination color model cannot be null");
    }
    srcCM = s;
    dstCM = d;
    this.composite = ac;
    this.comptype = CompositeType.forAlphaComposite(ac);
}
 

public SunCompositeContext(AlphaComposite ac,
                           ColorModel s, ColorModel d)
{
    if (s == null) {
        throw new NullPointerException("Source color model cannot be null");
    }
    if (d == null) {
        throw new NullPointerException("Destination color model cannot be null");
    }
    srcCM = s;
    dstCM = d;
    this.composite = ac;
    this.comptype = CompositeType.forAlphaComposite(ac);
}
 

OGLSwToSurfaceTransform(SurfaceType srcType, int typeval) {
    super(srcType,
          CompositeType.AnyAlpha,
          OGLSurfaceData.OpenGLSurface);
    this.typeval = typeval;
}
 

public X11PMBlitBgLoops(SurfaceType srcType, SurfaceType dstType)
{
    super(srcType, CompositeType.SrcNoEa, dstType);
}