Java Code Examples for java.awt.AlphaComposite#SRC_OVER

/**
 * Record information about drawing done
 * with the supplied <code>Composite</code>.
 */
private void checkAlpha(Composite composite) {

    if (composite instanceof AlphaComposite) {
        AlphaComposite alphaComposite = (AlphaComposite) composite;
        float alpha = alphaComposite.getAlpha();
        int rule = alphaComposite.getRule();

        if (alpha != 1.0
                || (rule != AlphaComposite.SRC
                    && rule != AlphaComposite.SRC_OVER)) {

            mHasCompositing = true;
        }

    } else {
        mHasCompositing = true;
    }

}
 

/**
 * Record information about drawing done
 * with the supplied <code>Composite</code>.
 */
private void checkAlpha(Composite composite) {

    if (composite instanceof AlphaComposite) {
        AlphaComposite alphaComposite = (AlphaComposite) composite;
        float alpha = alphaComposite.getAlpha();
        int rule = alphaComposite.getRule();

        if (alpha != 1.0
                || (rule != AlphaComposite.SRC
                    && rule != AlphaComposite.SRC_OVER)) {

            mHasCompositing = true;
        }

    } else {
        mHasCompositing = true;
    }

}
 

/**
 * Record information about drawing done
 * with the supplied <code>Composite</code>.
 */
private void checkAlpha(Composite composite) {

    if (composite instanceof AlphaComposite) {
        AlphaComposite alphaComposite = (AlphaComposite) composite;
        float alpha = alphaComposite.getAlpha();
        int rule = alphaComposite.getRule();

        if (alpha != 1.0
                || (rule != AlphaComposite.SRC
                    && rule != AlphaComposite.SRC_OVER)) {

            mHasCompositing = true;
        }

    } else {
        mHasCompositing = true;
    }

}
 

/**
 * Record information about drawing done
 * with the supplied <code>Composite</code>.
 */
private void checkAlpha(Composite composite) {

    if (composite instanceof AlphaComposite) {
        AlphaComposite alphaComposite = (AlphaComposite) composite;
        float alpha = alphaComposite.getAlpha();
        int rule = alphaComposite.getRule();

        if (alpha != 1.0
                || (rule != AlphaComposite.SRC
                    && rule != AlphaComposite.SRC_OVER)) {

            mHasCompositing = true;
        }

    } else {
        mHasCompositing = true;
    }

}
 

/**
 * Record information about drawing done
 * with the supplied {@code Composite}.
 */
private void checkAlpha(Composite composite) {

    if (composite instanceof AlphaComposite) {
        AlphaComposite alphaComposite = (AlphaComposite) composite;
        float alpha = alphaComposite.getAlpha();
        int rule = alphaComposite.getRule();

        if (alpha != 1.0
                || (rule != AlphaComposite.SRC
                    && rule != AlphaComposite.SRC_OVER)) {

            mHasCompositing = true;
        }

    } else {
        mHasCompositing = true;
    }

}
 

protected void PaintGradiente(Graphics2D g) { //, boolean round) {
    int dist = 0;
    DimensioneParaPintura();
    W -= dist;
    H -= dist;
    boolean dv = getGDirecao() == VERTICAL;

    int type = AlphaComposite.SRC_OVER;

    g.setComposite(AlphaComposite.getInstance(type, alfa));

    GradientPaint GP = new GradientPaint(L, T, getGradienteStartColor(), dv ? L : L + W, dv ? T + H : T, getGradienteEndColor(), true);
    g.setPaint(GP);

    if (roundrect > 0 && isPintarBorda()) {
        g.fillRoundRect(L + 1, T + 1, W, H, roundrect, roundrect);
    } else {
        g.fillRect(L + 1, T + 1, W, H);
    }
}
 

/**
 * Return a CompositeType object for the specified AlphaComposite
 * rule.
 */
public static CompositeType forAlphaComposite(AlphaComposite ac) {
    switch (ac.getRule()) {
    case AlphaComposite.CLEAR:
        return Clear;
    case AlphaComposite.SRC:
        if (ac.getAlpha() >= 1.0f) {
            return SrcNoEa;
        } else {
            return Src;
        }
    case AlphaComposite.DST:
        return Dst;
    case AlphaComposite.SRC_OVER:
        if (ac.getAlpha() >= 1.0f) {
            return SrcOverNoEa;
        } else {
            return SrcOver;
        }
    case AlphaComposite.DST_OVER:
        return DstOver;
    case AlphaComposite.SRC_IN:
        return SrcIn;
    case AlphaComposite.DST_IN:
        return DstIn;
    case AlphaComposite.SRC_OUT:
        return SrcOut;
    case AlphaComposite.DST_OUT:
        return DstOut;
    case AlphaComposite.SRC_ATOP:
        return SrcAtop;
    case AlphaComposite.DST_ATOP:
        return DstAtop;
    case AlphaComposite.XOR:
        return AlphaXor;
    default:
        throw new InternalError("Unrecognized alpha rule");
    }
}
 

private boolean canHandleComposite(Composite c) {
    if (c instanceof AlphaComposite) {
        AlphaComposite ac = (AlphaComposite)c;

        return ac.getRule() == AlphaComposite.SRC_OVER && ac.getAlpha() >= 1f;
    }
    return false;
}
 

private boolean canHandleComposite(Composite c) {
    if (c instanceof AlphaComposite) {
        AlphaComposite ac = (AlphaComposite)c;

        return ac.getRule() == AlphaComposite.SRC_OVER && ac.getAlpha() >= 1f;
    }
    return false;
}
 

private boolean canHandleComposite(Composite c) {
    if (c instanceof AlphaComposite) {
        AlphaComposite ac = (AlphaComposite)c;

        return ac.getRule() == AlphaComposite.SRC_OVER && ac.getAlpha() >= 1f;
    }
    return false;
}
 

/**
 * Return a CompositeType object for the specified AlphaComposite
 * rule.
 */
public static CompositeType forAlphaComposite(AlphaComposite ac) {
    switch (ac.getRule()) {
    case AlphaComposite.CLEAR:
        return Clear;
    case AlphaComposite.SRC:
        if (ac.getAlpha() >= 1.0f) {
            return SrcNoEa;
        } else {
            return Src;
        }
    case AlphaComposite.DST:
        return Dst;
    case AlphaComposite.SRC_OVER:
        if (ac.getAlpha() >= 1.0f) {
            return SrcOverNoEa;
        } else {
            return SrcOver;
        }
    case AlphaComposite.DST_OVER:
        return DstOver;
    case AlphaComposite.SRC_IN:
        return SrcIn;
    case AlphaComposite.DST_IN:
        return DstIn;
    case AlphaComposite.SRC_OUT:
        return SrcOut;
    case AlphaComposite.DST_OUT:
        return DstOut;
    case AlphaComposite.SRC_ATOP:
        return SrcAtop;
    case AlphaComposite.DST_ATOP:
        return DstAtop;
    case AlphaComposite.XOR:
        return AlphaXor;
    default:
        throw new InternalError("Unrecognized alpha rule");
    }
}
 

private boolean canHandleComposite(Composite c) {
    if (c instanceof AlphaComposite) {
        AlphaComposite ac = (AlphaComposite)c;

        return ac.getRule() == AlphaComposite.SRC_OVER && ac.getAlpha() >= 1f;
    }
    return false;
}
 

@Override
public void MaskBlit(SurfaceData src, SurfaceData dst,
                     Composite comp, Region clip,
                     int srcx, int srcy,
                     int dstx, int dsty,
                     int width, int height,
                     byte[] mask, int maskoff, int maskscan)
{
    if (width <= 0 || height <= 0) {
        return;
    }

    if (mask == null) {
        // no mask involved; delegate to regular blit loop
        if (blitop == null) {
            blitop = Blit.getFromCache(src.getSurfaceType(),
                                       CompositeType.AnyAlpha,
                                       this.getDestType());
        }
        blitop.Blit(src, dst,
                    comp, clip,
                    srcx, srcy, dstx, dsty,
                    width, height);
        return;
    }

    AlphaComposite acomp = (AlphaComposite)comp;
    if (acomp.getRule() != AlphaComposite.SRC_OVER) {
        comp = AlphaComposite.SrcOver;
    }

    rq.lock();
    try {
        validateContext(dst, comp, clip);

        RenderBuffer buf = rq.getBuffer();
        int totalBytesRequired = 20 + (width * height * 4);

        /*
         * REMIND: we should fix this so that it works with tiles that
         *         are larger than the entire buffer, but the native
         *         OGL/D3DMaskBlit isn't even prepared for tiles larger
         *         than 32x32 pixels, so there's no urgency here...
         */
        rq.ensureCapacity(totalBytesRequired);

        // enqueue parameters and tile pixels
        int newpos = enqueueTile(buf.getAddress(), buf.position(),
                                 src, src.getNativeOps(), srcTypeVal,
                                 mask, mask.length, maskoff, maskscan,
                                 srcx, srcy, dstx, dsty,
                                 width, height);

        buf.position(newpos);
    } finally {
        rq.unlock();
    }
}
 

@Override
public void MaskBlit(SurfaceData src, SurfaceData dst,
                     Composite comp, Region clip,
                     int srcx, int srcy,
                     int dstx, int dsty,
                     int width, int height,
                     byte[] mask, int maskoff, int maskscan)
{
    if (width <= 0 || height <= 0) {
        return;
    }

    if (mask == null) {
        // no mask involved; delegate to regular blit loop
        if (blitop == null) {
            blitop = Blit.getFromCache(src.getSurfaceType(),
                                       CompositeType.AnyAlpha,
                                       this.getDestType());
        }
        blitop.Blit(src, dst,
                    comp, clip,
                    srcx, srcy, dstx, dsty,
                    width, height);
        return;
    }

    AlphaComposite acomp = (AlphaComposite)comp;
    if (acomp.getRule() != AlphaComposite.SRC_OVER) {
        comp = AlphaComposite.SrcOver;
    }

    rq.lock();
    try {
        validateContext(dst, comp, clip);

        RenderBuffer buf = rq.getBuffer();
        int totalBytesRequired = 20 + (width * height * 4);

        /*
         * REMIND: we should fix this so that it works with tiles that
         *         are larger than the entire buffer, but the native
         *         OGL/D3DMaskBlit isn't even prepared for tiles larger
         *         than 32x32 pixels, so there's no urgency here...
         */
        rq.ensureCapacity(totalBytesRequired);

        // enqueue parameters and tile pixels
        int newpos = enqueueTile(buf.getAddress(), buf.position(),
                                 src, src.getNativeOps(), srcTypeVal,
                                 mask, mask.length, maskoff, maskscan,
                                 srcx, srcy, dstx, dsty,
                                 width, height);

        buf.position(newpos);
    } finally {
        rq.unlock();
    }
}
 

@Override
public void MaskFill(SunGraphics2D sg2d, SurfaceData sData,
                     Composite comp,
                     final int x, final int y, final int w, final int h,
                     final byte[] mask,
                     final int maskoff, final int maskscan)
{
    AlphaComposite acomp = (AlphaComposite)comp;
    if (acomp.getRule() != AlphaComposite.SRC_OVER) {
        comp = AlphaComposite.SrcOver;
    }

    rq.lock();
    try {
        validateContext(sg2d, comp, BufferedContext.USE_MASK);

        // we adjust the mask length so that the mask ends on a
        // 4-byte boundary
        int maskBytesRequired;
        if (mask != null) {
            // we adjust the mask length so that the mask ends on a
            // 4-byte boundary
            maskBytesRequired = (mask.length + 3) & (~3);
        } else {
            // mask not needed
            maskBytesRequired = 0;
        }
        int totalBytesRequired = 32 + maskBytesRequired;

        RenderBuffer buf = rq.getBuffer();
        if (totalBytesRequired <= buf.capacity()) {
            if (totalBytesRequired > buf.remaining()) {
                // process the queue first and then enqueue the mask
                rq.flushNow();
            }

            buf.putInt(MASK_FILL);
            // enqueue parameters
            buf.putInt(x).putInt(y).putInt(w).putInt(h);
            buf.putInt(maskoff);
            buf.putInt(maskscan);
            buf.putInt(maskBytesRequired);
            if (mask != null) {
                // enqueue the mask
                int padding = maskBytesRequired - mask.length;
                buf.put(mask);
                if (padding != 0) {
                    buf.position(buf.position() + padding);
                }
            }
        } else {
            // queue is too small to accommodate entire mask; perform
            // the operation directly on the queue flushing thread
            rq.flushAndInvokeNow(new Runnable() {
                public void run() {
                    maskFill(x, y, w, h,
                             maskoff, maskscan, mask.length, mask);
                }
            });
        }
    } finally {
        rq.unlock();
    }
}
 

@Override
public void MaskBlit(SurfaceData src, SurfaceData dst,
                     Composite comp, Region clip,
                     int srcx, int srcy,
                     int dstx, int dsty,
                     int width, int height,
                     byte[] mask, int maskoff, int maskscan)
{
    if (width <= 0 || height <= 0) {
        return;
    }

    if (mask == null) {
        // no mask involved; delegate to regular blit loop
        if (blitop == null) {
            blitop = Blit.getFromCache(src.getSurfaceType(),
                                       CompositeType.AnyAlpha,
                                       this.getDestType());
        }
        blitop.Blit(src, dst,
                    comp, clip,
                    srcx, srcy, dstx, dsty,
                    width, height);
        return;
    }

    AlphaComposite acomp = (AlphaComposite)comp;
    if (acomp.getRule() != AlphaComposite.SRC_OVER) {
        comp = AlphaComposite.SrcOver;
    }

    rq.lock();
    try {
        validateContext(dst, comp, clip);

        RenderBuffer buf = rq.getBuffer();
        int totalBytesRequired = 20 + (width * height * 4);

        /*
         * REMIND: we should fix this so that it works with tiles that
         *         are larger than the entire buffer, but the native
         *         OGL/D3DMaskBlit isn't even prepared for tiles larger
         *         than 32x32 pixels, so there's no urgency here...
         */
        rq.ensureCapacity(totalBytesRequired);

        // enqueue parameters and tile pixels
        int newpos = enqueueTile(buf.getAddress(), buf.position(),
                                 src, src.getNativeOps(), srcTypeVal,
                                 mask, mask.length, maskoff, maskscan,
                                 srcx, srcy, dstx, dsty,
                                 width, height);

        buf.position(newpos);
    } finally {
        rq.unlock();
    }
}
 

@Override
public void MaskBlit(SurfaceData src, SurfaceData dst,
                     Composite comp, Region clip,
                     int srcx, int srcy,
                     int dstx, int dsty,
                     int width, int height,
                     byte[] mask, int maskoff, int maskscan)
{
    if (width <= 0 || height <= 0) {
        return;
    }

    if (mask == null) {
        // no mask involved; delegate to regular blit loop
        if (blitop == null) {
            blitop = Blit.getFromCache(src.getSurfaceType(),
                                       CompositeType.AnyAlpha,
                                       this.getDestType());
        }
        blitop.Blit(src, dst,
                    comp, clip,
                    srcx, srcy, dstx, dsty,
                    width, height);
        return;
    }

    AlphaComposite acomp = (AlphaComposite)comp;
    if (acomp.getRule() != AlphaComposite.SRC_OVER) {
        comp = AlphaComposite.SrcOver;
    }

    rq.lock();
    try {
        validateContext(dst, comp, clip);

        RenderBuffer buf = rq.getBuffer();
        int totalBytesRequired = 20 + (width * height * 4);

        /*
         * REMIND: we should fix this so that it works with tiles that
         *         are larger than the entire buffer, but the native
         *         OGL/D3DMaskBlit isn't even prepared for tiles larger
         *         than 32x32 pixels, so there's no urgency here...
         */
        rq.ensureCapacity(totalBytesRequired);

        // enqueue parameters and tile pixels
        int newpos = enqueueTile(buf.getAddress(), buf.position(),
                                 src, src.getNativeOps(), srcTypeVal,
                                 mask, mask.length, maskoff, maskscan,
                                 srcx, srcy, dstx, dsty,
                                 width, height);

        buf.position(newpos);
    } finally {
        rq.unlock();
    }
}
 

@Override
public void MaskFill(SunGraphics2D sg2d, SurfaceData sData,
                     Composite comp,
                     final int x, final int y, final int w, final int h,
                     final byte[] mask,
                     final int maskoff, final int maskscan)
{
    AlphaComposite acomp = (AlphaComposite)comp;
    if (acomp.getRule() != AlphaComposite.SRC_OVER) {
        comp = AlphaComposite.SrcOver;
    }

    rq.lock();
    try {
        validateContext(sg2d, comp, BufferedContext.USE_MASK);

        // we adjust the mask length so that the mask ends on a
        // 4-byte boundary
        int maskBytesRequired;
        if (mask != null) {
            // we adjust the mask length so that the mask ends on a
            // 4-byte boundary
            maskBytesRequired = (mask.length + 3) & (~3);
        } else {
            // mask not needed
            maskBytesRequired = 0;
        }
        int totalBytesRequired = 32 + maskBytesRequired;

        RenderBuffer buf = rq.getBuffer();
        if (totalBytesRequired <= buf.capacity()) {
            if (totalBytesRequired > buf.remaining()) {
                // process the queue first and then enqueue the mask
                rq.flushNow();
            }

            buf.putInt(MASK_FILL);
            // enqueue parameters
            buf.putInt(x).putInt(y).putInt(w).putInt(h);
            buf.putInt(maskoff);
            buf.putInt(maskscan);
            buf.putInt(maskBytesRequired);
            if (mask != null) {
                // enqueue the mask
                int padding = maskBytesRequired - mask.length;
                buf.put(mask);
                if (padding != 0) {
                    buf.position(buf.position() + padding);
                }
            }
        } else {
            // queue is too small to accommodate entire mask; perform
            // the operation directly on the queue flushing thread
            rq.flushAndInvokeNow(new Runnable() {
                public void run() {
                    maskFill(x, y, w, h,
                             maskoff, maskscan, mask.length, mask);
                }
            });
        }
    } finally {
        rq.unlock();
    }
}
 

@Override
public void MaskFill(SunGraphics2D sg2d, SurfaceData sData,
                     Composite comp,
                     final int x, final int y, final int w, final int h,
                     final byte[] mask,
                     final int maskoff, final int maskscan)
{
    AlphaComposite acomp = (AlphaComposite)comp;
    if (acomp.getRule() != AlphaComposite.SRC_OVER) {
        comp = AlphaComposite.SrcOver;
    }

    rq.lock();
    try {
        validateContext(sg2d, comp, BufferedContext.USE_MASK);

        // we adjust the mask length so that the mask ends on a
        // 4-byte boundary
        int maskBytesRequired;
        if (mask != null) {
            // we adjust the mask length so that the mask ends on a
            // 4-byte boundary
            maskBytesRequired = (mask.length + 3) & (~3);
        } else {
            // mask not needed
            maskBytesRequired = 0;
        }
        int totalBytesRequired = 32 + maskBytesRequired;

        RenderBuffer buf = rq.getBuffer();
        if (totalBytesRequired <= buf.capacity()) {
            if (totalBytesRequired > buf.remaining()) {
                // process the queue first and then enqueue the mask
                rq.flushNow();
            }

            buf.putInt(MASK_FILL);
            // enqueue parameters
            buf.putInt(x).putInt(y).putInt(w).putInt(h);
            buf.putInt(maskoff);
            buf.putInt(maskscan);
            buf.putInt(maskBytesRequired);
            if (mask != null) {
                // enqueue the mask
                int padding = maskBytesRequired - mask.length;
                buf.put(mask);
                if (padding != 0) {
                    buf.position(buf.position() + padding);
                }
            }
        } else {
            // queue is too small to accommodate entire mask; perform
            // the operation directly on the queue flushing thread
            rq.flushAndInvokeNow(new Runnable() {
                public void run() {
                    maskFill(x, y, w, h,
                             maskoff, maskscan, mask.length, mask);
                }
            });
        }
    } finally {
        rq.unlock();
    }
}
 

private AlphaComposite makeComposite(double alpha) {
  int type = AlphaComposite.SRC_OVER;
  return (AlphaComposite.getInstance(type, (float) alpha));
}