private static BufferedImage makeBufferedImage(Icon icon, int w, int h) { BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB); Graphics2D g = image.createGraphics(); icon.paintIcon(null, g, (w - icon.getIconWidth()) / 2, (h - icon.getIconWidth()) / 2); g.dispose(); return image; }
@Override protected void paintBackground(Graphics g, JComponent component) { getGlassParameters(); Graphics2D g2d = (Graphics2D) g.create(); if (getOrientation().isHorizontal()) { paintBackground( g2d, 0, 0, component.getWidth(), component.getHeight(), getOrientation().isHorizontal(), component); } else { paintBackground( g2d, 0, 0, component.getHeight(), component.getWidth(), getOrientation().isHorizontal(), component); } g2d.dispose(); }
public BufferedImage createCrystalCase(Image cover) { BufferedImage crystal = new BufferedImage(IMAGE_WIDTH, IMAGE_HEIGHT, BufferedImage.TYPE_INT_ARGB); Graphics2D g2 = crystal.createGraphics(); g2.setRenderingHint( RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BILINEAR); int width = cover.getWidth(null); int height = cover.getHeight(null); float scale; if (width > height) { scale = (float) IMAGE_WIDTH / (float) width; } else { scale = (float) IMAGE_HEIGHT / (float) height; } int scaledWidth = (int) ((float) width * scale); int scaledHeight = (int) ((float) height * scale); int x = (IMAGE_WIDTH - scaledWidth) / 2; int y = (IMAGE_HEIGHT - scaledHeight) / 2; g2.drawImage(cover, x, y, scaledWidth, scaledHeight, null); g2.dispose(); return crystal; }
public BufferedImage filter(BufferedImage src, BufferedImage dst) { if (dst == null) dst = createCompatibleDestImage(src, null); int width = src.getWidth(); int height = src.getHeight(); int numScratches = (int) (density * width * height / 100); ArrayList<Line2D> lines = new ArrayList<Line2D>(); { float l = length * width; Random random = new Random(seed); Graphics2D g = dst.createGraphics(); g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); g.setColor(new Color(color)); g.setStroke(new BasicStroke(this.width)); for (int i = 0; i < numScratches; i++) { float x = width * random.nextFloat(); float y = height * random.nextFloat(); float a = angle + ImageMath.TWO_PI * (angleVariation * (random.nextFloat() - 0.5f)); float s = (float) Math.sin(a) * l; float c = (float) Math.cos(a) * l; float x1 = x - c; float y1 = y - s; float x2 = x + c; float y2 = y + s; g.drawLine((int) x1, (int) y1, (int) x2, (int) y2); lines.add(new Line2D.Float(x1, y1, x2, y2)); } g.dispose(); } if (false) { // int[] inPixels = getRGB( src, 0, 0, width, height, null ); int[] inPixels = new int[width * height]; int index = 0; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { float sx = x, sy = y; for (int i = 0; i < numScratches; i++) { Line2D.Float l = (Line2D.Float) lines.get(i); float dot = (l.x2 - l.x1) * (sx - l.x1) + (l.y2 - l.y1) * (sy - l.y1); if (dot > 0) inPixels[index] |= (1 << i); } index++; } } Colormap colormap = new LinearColormap(); index = 0; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { float f = (float) (inPixels[index] & 0x7fffffff) / 0x7fffffff; inPixels[index] = colormap.getColor(f); index++; } } setRGB(dst, 0, 0, width, height, inPixels); } return dst; }
public Image getImage() { BufferedImage image = new BufferedImage(getIconWidth(), getIconHeight(), BufferedImage.TYPE_INT_ARGB); Graphics2D g = image.createGraphics(); paintIcon(null, g, 0, 0); g.dispose(); return image; }
private void applyAlphaMask( BufferedImage buffer, BufferedImage alphaMask, int itemWidth, int itemHeight) { Graphics2D g2 = buffer.createGraphics(); g2.setComposite(AlphaComposite.DstOut); g2.drawImage(alphaMask, null, 0, itemHeight); g2.dispose(); }
@Override public void paintIcon(Component c, Graphics g, int x, int y) { Graphics2D g2 = (Graphics2D) g.create(); g2.translate(x, y); g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); g2.setPaint(Color.ORANGE); g2.fill(star); g2.dispose(); }
/** Draws this handle. */ public void draw(Graphics2D g) { Graphics2D gg = (Graphics2D) g.create(); gg.transform(view.getDrawingToViewTransform()); for (Connector c : connectors) { c.draw(gg); } gg.dispose(); drawCircle(g, (getTarget() == null) ? Color.red : Color.green, Color.black); }
public static BufferedImage cropImage(BufferedImage bi, int x, int y, int w, int h) { BufferedImage image = new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB); Graphics2D g2 = image.createGraphics(); g2.setRenderingHint( RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC); g2.setPaint(Color.white); g2.fillRect(0, 0, w, h); g2.drawImage(bi, -x, -y, null); // this); g2.dispose(); return image; }
public static BufferedImage scaleImage(BufferedImage bi, double scale) { int w1 = (int) (Math.round(scale * bi.getWidth())); int h1 = (int) (Math.round(scale * bi.getHeight())); BufferedImage image = new BufferedImage(w1, h1, BufferedImage.TYPE_INT_RGB); Graphics2D g2 = image.createGraphics(); g2.setRenderingHint( RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC); g2.setPaint(Color.white); g2.fillRect(0, 0, w1, h1); g2.drawImage(bi, 0, 0, w1, h1, null); // this); g2.dispose(); return image; }
public void paint(Graphics2D g2d) { Point p = getLocation(); if (p != null) { g2d = (Graphics2D) g2d.create(); g2d.setColor(Color.BLUE); Shape shape = getShape(); int x = (int) p.x - (shape.getBounds().width / 2); int y = (int) p.y - (shape.getBounds().height / 2); g2d.translate(x, y); g2d.fill(shape); g2d.dispose(); } }
/* * (non-Javadoc) * * @see javax.swing.Icon#paintIcon(java.awt.Component, java.awt.Graphics, * int, int) */ @Override public void paintIcon(Component c, Graphics g, int x, int y) { Graphics2D g2d = (Graphics2D) g.create(); g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); g2d.translate(x, y); double coef1 = (double) this.width / (double) getOrigWidth(); double coef2 = (double) this.height / (double) getOrigHeight(); double coef = Math.min(coef1, coef2); g2d.scale(coef, coef); paint(g2d); g2d.dispose(); }
public static BufferedImage rotateImage(BufferedImage bi) { int w = bi.getWidth(); int h = bi.getHeight(); BufferedImage image = new BufferedImage(h, w, BufferedImage.TYPE_INT_RGB); Graphics2D g2 = image.createGraphics(); g2.setRenderingHint( RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC); g2.setPaint(Color.white); // getBackground()); g2.fillRect(0, 0, h, w); g2.rotate(90 * Math.PI / 180); g2.drawImage(bi, 0, -h, w, h, null); // this); g2.dispose(); return image; }
@Override public void paintIcon(Component c, Graphics g, int x, int y) { if (image == null) { image = new BufferedImage(getIconWidth(), getIconHeight(), BufferedImage.TYPE_INT_ARGB); double coef = Math.min((double) width / (double) 68, (double) height / (double) 81); Graphics2D g2d = image.createGraphics(); g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); g2d.scale(coef, coef); paint(g2d); g2d.dispose(); } g.drawImage(image, x, y, null); }
private Shape generateShapeFromText() { Font font = new Font(fontFamily, Font.PLAIN, fontSize); BufferedImage img = new BufferedImage(100, 100, BufferedImage.TYPE_INT_ARGB); Graphics2D g2 = img.createGraphics(); try { GlyphVector vect = font.createGlyphVector(g2.getFontRenderContext(), str); float dispX = x; float dispY = (float) (y - vect.getVisualBounds().getY()); Shape shape = vect.getOutline(dispX, dispY); return shape; } finally { g2.dispose(); } }
/* * (non-Javadoc) * * @see javax.swing.Icon#paintIcon(java.awt.Component, java.awt.Graphics, * int, int) */ @Override public void paintIcon(Component c, Graphics g, int x, int y) { Graphics2D g2d = (Graphics2D) g.create(); g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); g2d.translate(x, y); Area clip = new Area(new Rectangle(0, 0, this.width, this.height)); if (g2d.getClip() != null) clip.intersect(new Area(g2d.getClip())); g2d.setClip(clip); double coef1 = (double) this.width / (double) getOrigWidth(); double coef2 = (double) this.height / (double) getOrigHeight(); double coef = Math.min(coef1, coef2); g2d.scale(coef, coef); paint(g2d); g2d.dispose(); }
private BufferedImage createReflection(BufferedImage item, int itemWidth, int itemHeight) { BufferedImage buffer = new BufferedImage(itemWidth, itemHeight << 1, BufferedImage.TYPE_INT_ARGB); Graphics2D g = buffer.createGraphics(); g.drawImage(item, null, null); g.translate(0, itemHeight << 1); AffineTransform reflectTransform = AffineTransform.getScaleInstance(1.0, -1.0); g.drawImage(item, reflectTransform, null); g.translate(0, -(itemHeight << 1)); g.dispose(); return buffer; }
public BufferedImage createGradientMask(int itemWidth, int itemHeight) { BufferedImage gradient = new BufferedImage(itemWidth, itemHeight, BufferedImage.TYPE_INT_ARGB); Graphics2D g = gradient.createGraphics(); GradientPaint painter = new GradientPaint( 0.0f, 0.0f, new Color(1.0f, 1.0f, 1.0f, 0.5f), 0.0f, itemHeight / 2.0f, new Color(1.0f, 1.0f, 1.0f, 1.0f)); g.setPaint(painter); g.fill(new Rectangle2D.Double(0, 0, itemWidth, itemHeight)); g.dispose(); return gradient; }
@Override public void draw(Graphics2D g) { double opacity = get(OPACITY); opacity = Math.min(Math.max(0d, opacity), 1d); if (opacity != 0d) { if (opacity != 1d) { Rectangle2D.Double drawingArea = getDrawingArea(); Rectangle2D clipBounds = g.getClipBounds(); if (clipBounds != null) { Rectangle2D.intersect(drawingArea, clipBounds, drawingArea); } if (!drawingArea.isEmpty()) { BufferedImage buf = new BufferedImage( (int) ((2 + drawingArea.width) * g.getTransform().getScaleX()), (int) ((2 + drawingArea.height) * g.getTransform().getScaleY()), BufferedImage.TYPE_INT_ARGB); Graphics2D gr = buf.createGraphics(); gr.scale(g.getTransform().getScaleX(), g.getTransform().getScaleY()); gr.translate((int) -drawingArea.x, (int) -drawingArea.y); gr.setRenderingHints(g.getRenderingHints()); drawFigure(gr); gr.dispose(); Composite savedComposite = g.getComposite(); g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, (float) opacity)); g.drawImage( buf, (int) drawingArea.x, (int) drawingArea.y, 2 + (int) drawingArea.width, 2 + (int) drawingArea.height, null); g.setComposite(savedComposite); } } else { drawFigure(g); } } }
public BufferedImage filter(BufferedImage src, BufferedImage dst) { int w = src.getWidth(); int h = src.getHeight(); if (dst == null) { ColorModel dstCM = src.getColorModel(); dst = new BufferedImage( dstCM, dstCM.createCompatibleWritableRaster(width, height), dstCM.isAlphaPremultiplied(), null); } Graphics2D g = dst.createGraphics(); g.drawRenderedImage(src, AffineTransform.getTranslateInstance(-x, -y)); g.dispose(); return dst; }
@Override public void paintComponent(Graphics g) { g.setColor(getBackground()); g.fillRect(0, 0, getWidth(), getHeight()); int w = bufferedImage.getWidth(this); int h = bufferedImage.getHeight(this); if (mode == Flip.NONE) { g.drawImage(bufferedImage, 0, 0, w, h, this); } else if (mode == Flip.VERTICAL) { AffineTransform at = AffineTransform.getScaleInstance(1d, -1d); at.translate(0, -h); Graphics2D g2 = (Graphics2D) g.create(); g2.drawImage(bufferedImage, at, this); g2.dispose(); } else if (mode == Flip.HORIZONTAL) { AffineTransform at = AffineTransform.getScaleInstance(-1d, 1d); at.translate(-w, 0); AffineTransformOp atOp = new AffineTransformOp(at, null); g.drawImage(atOp.filter(bufferedImage, null), 0, 0, w, h, this); } }
private static int[] makeGradientPallet() { BufferedImage image = new BufferedImage(100, 1, BufferedImage.TYPE_INT_RGB); Graphics2D g2 = image.createGraphics(); Point2D start = new Point2D.Float(0f, 0f); Point2D end = new Point2D.Float(99f, 0f); float[] dist = {0f, .5f, 1f}; Color[] colors = {Color.RED, Color.YELLOW, Color.GREEN}; g2.setPaint(new LinearGradientPaint(start, end, dist, colors)); g2.fillRect(0, 0, 100, 1); g2.dispose(); int width = image.getWidth(null); int[] pallet = new int[width]; PixelGrabber pg = new PixelGrabber(image, 0, 0, width, 1, pallet, 0, width); try { pg.grabPixels(); } catch (InterruptedException ex) { ex.printStackTrace(); } return pallet; }
public BufferedImage filter(BufferedImage src, BufferedImage dst) { int width = src.getWidth(); int height = src.getHeight(); if (dst == null) dst = new BufferedImage( width + leftBorder + rightBorder, height + topBorder + bottomBorder, src.getType()); Graphics2D g = dst.createGraphics(); if (borderPaint != null) { g.setPaint(borderPaint); if (leftBorder > 0) g.fillRect(0, 0, leftBorder, height); if (rightBorder > 0) g.fillRect(width - rightBorder, 0, rightBorder, height); if (topBorder > 0) g.fillRect(leftBorder, 0, width - leftBorder - rightBorder, topBorder); if (bottomBorder > 0) g.fillRect( leftBorder, height - bottomBorder, width - leftBorder - rightBorder, bottomBorder); } g.drawRenderedImage(src, AffineTransform.getTranslateInstance(leftBorder, rightBorder)); g.dispose(); return dst; }
@Override public void paintIcon(Component c, Graphics g, int x, int y) { Graphics2D g2 = (Graphics2D) g.create(); g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); g2.translate(x, y); g2.setStroke(new BasicStroke(BORDER_WIDTH)); g2.setPaint(LINE_COLOR); g2.draw(BORDER); g2.setStroke(new BasicStroke(SLIT_WIDTH)); g2.setColor(UIManager.getColor("Panel.background")); int n = SLIT_NUM + 1; int v = ICON_SIZE / n; int m = n * v; for (int i = 1; i < n; i++) { int a = i * v; g2.drawLine(a, 0, a, m); g2.drawLine(0, a, m, a); } // g2.drawLine(1 * v, 0 * v, 1 * v, 4 * v); // g2.drawLine(2 * v, 0 * v, 2 * v, 4 * v); // g2.drawLine(3 * v, 0 * v, 3 * v, 4 * v); // g2.drawLine(0 * v, 1 * v, 4 * v, 1 * v); // g2.drawLine(0 * v, 2 * v, 4 * v, 2 * v); // g2.drawLine(0 * v, 3 * v, 4 * v, 3 * v); g2.setPaint(LINE_COLOR); Rectangle2D b = ARROW.getBounds(); Point2D p = new Point2D.Double(b.getX() + b.getWidth() / 2d, b.getY() + b.getHeight() / 2d); AffineTransform toCenterAT = AffineTransform.getTranslateInstance(ICON_SIZE / 2d - p.getX(), ICON_SIZE / 2d - p.getY()); g2.fill(toCenterAT.createTransformedShape(ARROW)); g2.dispose(); }
public void paint(Graphics g) { float ffc, flw; int cw, ch; Graphics2D g2 = (Graphics2D) g; Dmax = canvas.getSize(); cw = Dmax.width; ch = Dmax.height; if (bimw != cw || bimh != ch) { if (bimw != cw || bimh != ch) { bim = (BufferedImage) createImage(cw, ch); } Graphics2D bimg2 = bim.createGraphics(); bimg2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); bimg2.setBackground(DatanGraphics.ct[0]); bimg2.clearRect(0, 0, cw, ch); DminInner.width = Dmin.width + 1; DminInner.height = Dmin.height + 1; DmaxInner.width = Dmax.width - 2; DmaxInner.height = Dmax.height - 2; bimg2.setTransform(affTransf(DminInner, DmaxInner, dmin, dmax)); drawPolylines(bimg2); bimw = cw; bimh = ch; bimg2.dispose(); bimg2 = null; } g2.drawImage(bim, 0, 0, this); }
public void run() { Thread me = Thread.currentThread(); while (getSize().width <= 0) { try { anim.sleep(500); } catch (InterruptedException e) { return; } } Graphics2D g2d = null; Graphics2D BufferG2D = null; Graphics2D ScreenG2D = null; BasicStroke solid = new BasicStroke(9.0f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_ROUND, 9.0f); GeneralPath gp = new GeneralPath(GeneralPath.WIND_NON_ZERO); int rule = AlphaComposite.SRC_OVER; AlphaComposite opaque = AlphaComposite.SrcOver; AlphaComposite blend = AlphaComposite.getInstance(rule, 0.9f); AlphaComposite set = AlphaComposite.Src; int frame = 0; int frametmp = 0; Dimension oldSize = getSize(); Shape clippath = null; while (anim == me) { Dimension size = getSize(); if (size.width != oldSize.width || size.height != oldSize.height) { img = null; clippath = null; if (BufferG2D != null) { BufferG2D.dispose(); BufferG2D = null; } if (ScreenG2D != null) { ScreenG2D.dispose(); ScreenG2D = null; } } oldSize = size; if (img == null) { img = (BufferedImage) createImage(size.width, size.height); } if (BufferG2D == null) { BufferG2D = img.createGraphics(); BufferG2D.setRenderingHint( RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_DEFAULT); BufferG2D.setClip(clippath); } g2d = BufferG2D; float[] ctrlpts; for (int i = 0; i < animpts.length; i += 2) { animate(animpts, deltas, i + 0, size.width); animate(animpts, deltas, i + 1, size.height); } ctrlpts = animpts; int len = ctrlpts.length; gp.reset(); int dir = 0; float prevx = ctrlpts[len - 2]; float prevy = ctrlpts[len - 1]; float curx = ctrlpts[0]; float cury = ctrlpts[1]; float midx = (curx + prevx) / 2.0f; float midy = (cury + prevy) / 2.0f; gp.moveTo(midx, midy); for (int i = 2; i <= ctrlpts.length; i += 2) { float x1 = (midx + curx) / 2.0f; float y1 = (midy + cury) / 2.0f; prevx = curx; prevy = cury; if (i < ctrlpts.length) { curx = ctrlpts[i + 0]; cury = ctrlpts[i + 1]; } else { curx = ctrlpts[0]; cury = ctrlpts[1]; } midx = (curx + prevx) / 2.0f; midy = (cury + prevy) / 2.0f; float x2 = (prevx + midx) / 2.0f; float y2 = (prevy + midy) / 2.0f; gp.curveTo(x1, y1, x2, y2, midx, midy); } gp.closePath(); g2d.setComposite(set); g2d.setBackground(backgroundColor); g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF); if (bgChanged || bounds == null) { bounds = new Rectangle(0, 0, getWidth(), getHeight()); bgChanged = false; } // g2d.clearRect(bounds.x-5, bounds.y-5, bounds.x + bounds.width + 5, bounds.y + bounds.height // + 5); g2d.clearRect(0, 0, getWidth(), getHeight()); g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); g2d.setColor(outerColor); g2d.setComposite(opaque); g2d.setStroke(solid); g2d.draw(gp); g2d.setPaint(gradient); if (!bgChanged) { bounds = gp.getBounds(); } else { bounds = new Rectangle(0, 0, getWidth(), getHeight()); bgChanged = false; } gradient = new GradientPaint( bounds.x, bounds.y, gradientColorA, bounds.x + bounds.width, bounds.y + bounds.height, gradientColorB, true); g2d.setComposite(blend); g2d.fill(gp); if (g2d == BufferG2D) { repaint(); } ++frame; Thread.yield(); } if (g2d != null) { g2d.dispose(); } }
/** * Do the filter operation * * @param src The source BufferedImage. Can be any type. * @param dst The destination image. If not null, must be of type TYPE_INT_RGB, TYPE_INT_ARGB or * TYPE_INT_ARGB_PRE * @return the filtered image */ public BufferedImage filter(BufferedImage src, BufferedImage dst) { int width = src.getWidth(); int height = src.getHeight(); BufferedImageConsumer consumer = new BufferedImageConsumer(dst); ImageFilter fltr = filter.getFilterInstance(consumer); fltr.setDimensions(width, height); /* ColorModel cm = src.getColorModel(); if (cm.getPixelSize() == 8) { // byte. indexed or gray: WritableRaster raster = src.getRaster(); byte pixels[] = new byte[width]; // calculate scanline by scanline in order to safe memory. // It also seems to run faster like that for (int y = 0; y < height; y++) { raster.getDataElements(0, y, width, 1, pixels); fltr.setPixels(0, y, width, 1, cm, pixels, 0, width); } } else { // integer, use the simple rgb mode: WritableRaster raster = src.getRaster(); int pixels[] = new int[width]; // calculate scanline by scanline in order to safe memory. // It also seems to run faster like that for (int y = 0; y < height; y++) { raster.getDataElements(0, y, width, 1, pixels); fltr.setPixels(0, y, width, 1, cm, pixels, 0, width); } } */ // Always work in integer mode. this is more effective, and most // filters convert to integer internally anyhow ColorModel cm = new SimpleColorModel(); // Create a BufferedImage of only 1 pixel height for fetching the rows of the image in the // correct format (ARGB) // This speeds up things by more than factor 2, compared to the standard BufferedImage.getRGB // solution, // which is supposed to be fast too. This is probably the case because drawing to BufferedImages // uses // very optimized code which may even be hardware accelerated. BufferedImage row = new BufferedImage(width, 1, BufferedImage.TYPE_INT_ARGB); Graphics2D g2d = row.createGraphics(); int pixels[] = ((DataBufferInt) row.getRaster().getDataBuffer()).getData(); // Make sure alpha values do not add up for each row: g2d.setComposite(AlphaComposite.Src); // Calculate scanline by scanline in order to safe memory. // It also seems to run faster like that for (int y = 0; y < height; y++) { g2d.drawImage(src, null, 0, -y); // Now pixels contains the rgb values of the row y! // filter this row now: fltr.setPixels(0, y, width, 1, cm, pixels, 0, width); } g2d.dispose(); // The consumer now contains the filtered image, return it. return consumer.getImage(); }
/** [Advanced] */ public void dispose() { Graphics2D g = getG(); if (g != null) g.dispose(); }
protected void paintBackground( Graphics g, int x, int y, int w, int h, boolean horizontal, JComponent component) { Graphics2D g2d = (Graphics2D) g.create(); CEclipseBorder ec = null; Insets ins = getOutsideInsets(); x = ins.left; y = ins.top; if (getOrientation().isHorizontal()) { w -= ins.left + ins.right; h -= ins.top + ins.bottom; } else { w -= ins.top + ins.bottom; h -= ins.left + ins.right; } if (component.getBorder() instanceof CompoundBorder) { CompoundBorder cb = (CompoundBorder) component.getBorder(); CompoundBorder bb = (CompoundBorder) cb.getInsideBorder(); ec = (CEclipseBorder) bb.getOutsideBorder(); } if (w > 0 && h > 0) { if (glassStrip != null) { BufferedImage im = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB); Graphics2D gg = im.createGraphics(); gg.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); gg.setColor(component.getBackground()); if (ec != null) { gg.fill(ec.createShape(0, 0, w, h, ec.getCornerRadius())); } else { gg.fillRect(0, 0, w, h); } if (!isSelected()) { gg.setComposite(AlphaComposite.SrcIn); } else { gg.setComposite(AlphaComposite.SrcAtop); } try { glass.Render2Graphics(new Dimension(w, h), gg, glassStrip, true); } catch (Exception e) { glass.Render2Graphics(new Dimension(w, h), gg, CGlassFactory.VALUE_STEEL, true); } gg.dispose(); if (!getOrientation().isHorizontal()) { AffineTransform atTrans = AffineTransform.getTranslateInstance(x /* + h */, y + w); atTrans.concatenate(COutlineHelper.tRot90CCW); g2d.drawImage(im, atTrans, null); } else { g2d.drawImage(im, x, y, null); } } g2d.dispose(); } }