Java 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}.
 */
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;
    }

}
 

public void DrawImagem(Graphics2D g) {
    BufferedImage imgB = getImagem();
    if (imgB == null) {
        return;
    }
    Rectangle rec = getBounds();
    rec.grow(-2, -2);
    if (imgres == null) {
        imgres = imgB.getScaledInstance(rec.width, rec.height, Image.SCALE_SMOOTH);
    }

    Composite originalComposite = g.getComposite();
    if (alfa != 1f) {
        int type = AlphaComposite.SRC_OVER;
        g.setComposite(AlphaComposite.getInstance(type, alfa));
    }
    Image img = imgres;
    if (isDisablePainted()) {
        img = util.Utilidades.dye(new ImageIcon(imgres), disabledColor);
    }
    
    g.drawImage(img, rec.x, rec.y, null);
    g.setComposite(originalComposite);
}
 

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;
}
 

protected void PaintGradiente(Graphics2D g) { //, boolean round) {
        Paint bkp = g.getPaint();
        int dist = distSelecao;

        int W = getWidth() - dist;
        int H = 2 * alturaTexto - 1 - dist;
        boolean dv = getGDirecao() == VERTICAL;

        Composite originalComposite = g.getComposite();
        int type = AlphaComposite.SRC_OVER;

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

        Stroke bkps = g.getStroke();
        if (isDashed()) {
            g.setStroke(new BasicStroke(1, BasicStroke.CAP_BUTT, BasicStroke.JOIN_BEVEL, 0, new float[]{1, 2}, 0));
        }

//        GradientPaint GP = new GradientPaint(getLeft(), getTop(), Color.LIGHT_GRAY, dv ? getLeft() : getLeft() + W, dv ? getTop() + H : getTop(), Color.white, true);
//        g.setPaint(GP);
        int w = getWidth() - dist;
        int h = getHeight() - dist;
        int L = getLeft();
        int T = getTop();

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

        g.fillRect(getLeft() + 1, getTop() + 1, W, H);
        g.setComposite(originalComposite);
        g.setPaint(bkp);
        g.setStroke(bkps);
    }
 

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

@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();
    }
}
 

/**
 * Creates a new AlphaCompositeContext.
 *
 * @param aComp the AlphaComposite object 
 * @param srcCM the source color model
 * @param dstCM the destination color model
 */
public SunCompositeContext(AlphaComposite aComp, ColorModel srcCM,
                             ColorModel dstCM)
{
  composite = aComp;
  srcColorModel = srcCM;
  dstColorModel = dstCM;

  
  // Determine the blending factors according to the rule in the
  // AlphaComposite. For some rules the factors must be determined
  // dynamically because they depend on the actual pixel value.
  switch (composite.getRule())
  {
    case AlphaComposite.CLEAR:
      fs = 0.F;
      fd= 0.F;
      break;
    case AlphaComposite.DST:
      fs = 0.F;
      fd= 1.F;
      break;
    case AlphaComposite.DST_ATOP:
      fs = 1.F; // Determined later as 1 - alpha_dst;
      fd = 1.F; // Determined later as alpha_src;
      break;
    case AlphaComposite.DST_IN:
      fs = 0.F;
      fd = 0.F; // Determined later as alpha_src;
      break;
    case AlphaComposite.DST_OUT:
      fs = 0.F;
      fd = 0.F; // Determined later as 1 - alpha_src;
      break;
    case AlphaComposite.DST_OVER:
      fs = 1.F; // Determined later as 1 - alpha_dst.
      fd= 1.F;
      break;
    case AlphaComposite.SRC:
      fs = 1.F;
      fd= 0.F;
      break;
    case AlphaComposite.SRC_ATOP:
      fs = 1.F; // Determined later as alpha_dst;
      fd = 1.F; // Determined later as 1 - alpha_src;
      break;
    case AlphaComposite.SRC_IN:
      fs = 0.F; // Determined later as alpha_dst;
      fd = 0.F;
      break;
    case AlphaComposite.SRC_OUT:
      fs = 0.F; // Determined later as 1 - alpha_dst;
      fd = 0.F;
      break;
    case AlphaComposite.SRC_OVER:
      fs = 1.F;
      fd= 1.F; // Determined later as 1 - alpha_src.
      break;
    case AlphaComposite.XOR:
      fs = 1.F; // Determined later as 1 - alpha_dst.
      fd= 1.F; // Determined later as 1 - alpha_src.
      break;
    default:
      throw new AWTError("Illegal AlphaComposite rule");
  }

}