Java 我可以在swing中在组件边界之外绘制吗？

可能重复：

我想使用Swing（和SwingX）制作“好看”的界面，但我仍在努力创建漂亮的阴影。我发现在SwingX中已经有一个边界，可以（部分地）做我想做的事情

我还发现，阴影非常好，但它与图像一起工作。但是我相信您可以使它与

JComponent

一起工作。我已经修改了代码，生成了一个具有组件大小的空

buffereImage

（它只适用于矩形组件，但我并不在意），并从该图像创建了阴影

阴影生成可以工作，但我的问题是，我只能在swing组件的边界内渲染阴影，但我必须在两个轴上都使用偏移来渲染阴影

我可以避免这种情况并在组件边界之外进行渲染吗？例如，我可以在尺寸为（50，50）的组件的paintComponent方法中在（0，100）处绘制任何东西吗？

谢谢

编辑：下面是一个我想要避免的例子。阴影超出了两个轴的组件的大小（渲染组件不是为了让您看到阴影）

EDIT2：我不确定我是否足够清楚（如果是这样的话，我很抱歉），所以这里用图形表示我想做的事情

此代码可能会对您有所帮助

import java.awt.*;
import java.awt.geom.*;
import java.awt.image.ColorModel;
import java.awt.image.Raster;
import java.awt.image.WritableRaster;
import javax.swing.*;
import javax.swing.event.*;

public class Panel2Test {

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {

            @Override
            public void run() {
                ShadeOptionsPanel shadeOptions = new ShadeOptionsPanel();
                ShadowSelector shadowSelector = new ShadowSelector(shadeOptions);
                //ComponentSource componentSource = new ComponentSource(shadeOptions);
                JFrame f = new JFrame("Rounded Concept Demo with Shadows");
                f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                f.add(shadowSelector, "North");
                f.add(shadeOptions);
                //f.add(componentSource, "South");
                f.setSize(300, 200);
                f.setLocation(150, 150);
                f.setVisible(true);
            }
        });
    }

    private Panel2Test() {
    }
}

class ShadeOptionsPanel extends JPanel {

    private static final long serialVersionUID = 1L;
    private final int PAD, DIA, BORDER;
    private Color colorIn, colorOut;
    private int xc, yc;
    private Ellipse2D eIn, eOut;
    private GradientPaint gradient;
    private CustomPaint customPaint;
    private Area arcBorder;
    private int width, height;
    private Point2D neOrigin, nwOrigin, swOrigin, seOrigin, neDiag, nwDiag, swDiag, seDiag;
    private final static int NORTHEAST = 0, NORTHWEST = 1, SOUTHWEST = 2, SOUTHEAST = 3;
    public int shadowVertex = 3;

    public ShadeOptionsPanel() {
        PAD = 25;
        DIA = 75;
        BORDER = 10;
        colorIn = Color.black;
        colorOut = getBackground();
    }

    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2 = (Graphics2D) g;
        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        width = getWidth();
        height = getHeight();
        g2.drawRoundRect(PAD, PAD, width - 2 * PAD, height - 2 * PAD, DIA, DIA);
        calculateArcOrigins();
        calculateCardinalDiagonals();
        drawVertexArc(g2, shadowVertex);
        switch (shadowVertex) {
            case NORTHEAST:
                drawNorthSide(g2);
                drawEastSide(g2);
                xc = PAD + DIA / 2; // draw northwest arc
                yc = PAD + DIA / 2;
                customPaint = new CustomPaint(xc, yc, new Point2D.Double(0, DIA / 2),
                        DIA / 2, BORDER, colorIn, colorOut);
                g2.setPaint(customPaint);
                eIn = getInnerEllipse(nwOrigin, nwDiag);
                eOut = getOuterEllipse(nwOrigin, nwDiag);
                arcBorder = getArcArea(eIn, eOut, 90.0);
                g2.fill(arcBorder);
                xc = width - PAD - DIA / 2; // draw southeast arc
                yc = height - PAD - DIA / 2;
                customPaint = new CustomPaint(xc, yc, new Point2D.Double(0, DIA / 2),
                        DIA / 2, BORDER, colorIn, colorOut);
                g2.setPaint(customPaint);
                eIn = getInnerEllipse(seOrigin, seDiag);
                eOut = getOuterEllipse(seOrigin, seDiag);
                arcBorder = getArcArea(eIn, eOut, 270.0);
                g2.fill(arcBorder);
                break;
            case NORTHWEST:
                drawNorthSide(g2);
                drawWestSide(g2);
                xc = width - PAD - DIA / 2;// draw northeast arc
                yc = PAD + DIA / 2;
                customPaint = new CustomPaint(xc, yc, new Point2D.Double(0, DIA / 2),
                        DIA / 2, BORDER, colorIn, colorOut);
                g2.setPaint(customPaint);
                eIn = getInnerEllipse(neOrigin, neDiag);
                eOut = getOuterEllipse(neOrigin, neDiag);
                arcBorder = getArcArea(eIn, eOut, 0.0);
                g2.fill(arcBorder);
                xc = PAD + DIA / 2;// draw southwest arc
                yc = height - PAD - DIA / 2;
                customPaint = new CustomPaint(xc, yc, new Point2D.Double(0, DIA / 2),
                        DIA / 2, BORDER, colorIn, colorOut);
                g2.setPaint(customPaint);
                eIn = getInnerEllipse(swOrigin, swDiag);
                eOut = getOuterEllipse(swOrigin, swDiag);
                arcBorder = getArcArea(eIn, eOut, 180.0);
                g2.fill(arcBorder);
                break;
            case SOUTHWEST:
                drawWestSide(g2);
                drawSouthSide(g2);
                xc = PAD + DIA / 2; // draw northwest arc
                yc = PAD + DIA / 2;
                customPaint = new CustomPaint(xc, yc, new Point2D.Double(0, DIA / 2),
                        DIA / 2, BORDER, colorIn, colorOut);
                g2.setPaint(customPaint);
                eIn = getInnerEllipse(nwOrigin, nwDiag);
                eOut = getOuterEllipse(nwOrigin, nwDiag);
                arcBorder = getArcArea(eIn, eOut, 90.0);
                g2.fill(arcBorder);
                xc = width - PAD - DIA / 2; // draw the southeast arc
                yc = height - PAD - DIA / 2;
                customPaint = new CustomPaint(xc, yc, new Point2D.Double(0, DIA / 2),
                        DIA / 2, BORDER, colorIn, colorOut);
                g2.setPaint(customPaint);
                eIn = getInnerEllipse(seOrigin, seDiag);
                eOut = getOuterEllipse(seOrigin, seDiag);
                arcBorder = getArcArea(eIn, eOut, 270.0);
                g2.fill(arcBorder);
                break;
            case SOUTHEAST:
                drawEastSide(g2);
                drawSouthSide(g2);
                xc = width - PAD - DIA / 2; // draw northeast arc
                yc = PAD + DIA / 2;
                customPaint = new CustomPaint(xc, yc, new Point2D.Double(0, DIA / 2),
                        DIA / 2, BORDER, colorIn, colorOut);
                g2.setPaint(customPaint);
                eIn = getInnerEllipse(neOrigin, neDiag);
                eOut = getOuterEllipse(neOrigin, neDiag);
                arcBorder = getArcArea(eIn, eOut, 0.0);
                g2.fill(arcBorder);
                xc = PAD + DIA / 2;  // draw southwest arc
                yc = height - PAD - DIA / 2;
                customPaint = new CustomPaint(xc, yc, new Point2D.Double(0, DIA / 2),
                        DIA / 2, BORDER, colorIn, colorOut);
                g2.setPaint(customPaint);
                eIn = getInnerEllipse(swOrigin, swDiag);
                eOut = getOuterEllipse(swOrigin, swDiag);
                arcBorder = getArcArea(eIn, eOut, 180.0);
                g2.fill(arcBorder);
        }
    }

    private Ellipse2D getInnerEllipse(Point2D center, Point2D corner) {
        return new Ellipse2D.Double(center.getX() - DIA / 2,
                center.getY() - DIA / 2, DIA, DIA);
    }

    private Ellipse2D getOuterEllipse(Point2D center, Point2D corner) {
        int w = DIA, h = DIA;
        if (shadowVertex < 2) {
            if (center.getY() > corner.getY()) {
                h += 2 * BORDER;
            } else {
                w += 2 * BORDER;
            }
        } else if (center.getY() > corner.getY()) {
            w += 2 * BORDER;
        } else {
            h += 2 * BORDER;
        }
        return new Ellipse2D.Double(center.getX() - w / 2, center.getY() - h / 2, w, h);
    }

    private Area getArcArea(Ellipse2D e1, Ellipse2D e2, double start) {
        Arc2D arc1 = new Arc2D.Double(e1.getBounds2D(), start, 90.0, Arc2D.PIE);
        Arc2D arc2 = new Arc2D.Double(e2.getBounds2D(), start, 90.0, Arc2D.PIE);
        Area arc = new Area(arc2);
        arc.subtract(new Area(arc1));
        return arc;
    }

    private void drawNorthSide(Graphics2D g2) {
        gradient = new GradientPaint(width / 2, PAD - BORDER, colorOut,
                width / 2, PAD, colorIn);
        g2.setPaint(gradient);
        g2.fill(new Rectangle2D.Double(PAD + DIA / 2, PAD - BORDER,
                width - 2 * (PAD + DIA / 2) + 1, BORDER));
    }

    private void drawWestSide(Graphics2D g2) {
        gradient = new GradientPaint(PAD - BORDER, height / 2, colorOut,
                PAD, height / 2, colorIn);
        g2.setPaint(gradient);
        g2.fill(new Rectangle2D.Double(PAD - BORDER, PAD + DIA / 2,
                BORDER, height - 2 * (PAD + DIA / 2) + 1));
    }

    private void drawSouthSide(Graphics2D g2) {
        gradient = new GradientPaint(width / 2, height - PAD, colorIn,
                width / 2, height - PAD + BORDER, colorOut);
        g2.setPaint(gradient);
        g2.fill(new Rectangle2D.Double(PAD + DIA / 2, height - PAD,
                width - 2 * (PAD + DIA / 2) + 1, BORDER));
    }

    private void drawEastSide(Graphics2D g2) {
        gradient = new GradientPaint(width - PAD, height / 2, colorIn,
                width - PAD + BORDER, height / 2, colorOut);
        g2.setPaint(gradient);
        g2.fill(new Rectangle2D.Double(width - PAD, PAD + DIA / 2,
                BORDER, height - 2 * (PAD + DIA / 2) + 1));
    }

    /**
     * Draws the central, full-shaded arc (opposite of the unshaded arc).
     */
    private void drawVertexArc(Graphics2D g2, int index) {
        switch (index) {
            case NORTHEAST:
                xc = width - PAD - DIA / 2;
                yc = PAD + DIA / 2;
                customPaint = new CustomPaint(xc, yc, new Point2D.Double(0, DIA / 2),
                        DIA / 2, BORDER, colorIn, colorOut);
                g2.setPaint(customPaint);
                eIn = new Ellipse2D.Double(width - PAD - DIA, PAD, DIA, DIA);
                eOut = new Ellipse2D.Double(width - PAD - DIA - BORDER, PAD - BORDER,
                        DIA + 2 * BORDER, DIA + 2 * BORDER);
                arcBorder = getArcArea(eIn, eOut, 0.0);
                g2.fill(arcBorder);
                break;
            case NORTHWEST:
                xc = PAD + DIA / 2;
                yc = PAD + DIA / 2;
                customPaint = new CustomPaint(xc, yc, new Point2D.Double(0, DIA / 2),
                        DIA / 2, BORDER, colorIn, colorOut);
                g2.setPaint(customPaint);
                eIn = new Ellipse2D.Double(PAD, PAD, DIA, DIA);
                eOut = new Ellipse2D.Double(PAD - BORDER, PAD - BORDER,
                        DIA + 2 * BORDER, DIA + 2 * BORDER);
                arcBorder = getArcArea(eIn, eOut, 90.0);
                g2.fill(arcBorder);
                break;
            case SOUTHWEST:
                xc = PAD + DIA / 2;
                yc = height - PAD - DIA / 2;
                customPaint = new CustomPaint(xc, yc, new Point2D.Double(0, DIA / 2),
                        DIA / 2, BORDER, colorIn, colorOut);
                g2.setPaint(customPaint);
                eIn = new Ellipse2D.Double(PAD, height - PAD - DIA, DIA, DIA);
                eOut = new Ellipse2D.Double(PAD - BORDER, height - PAD - DIA - BORDER,
                        DIA + 2 * BORDER, DIA + 2 * BORDER);
                arcBorder = getArcArea(eIn, eOut, 180.0);
                g2.fill(arcBorder);
                break;
            case SOUTHEAST:
                xc = width - PAD - DIA / 2;
                yc = height - PAD - DIA / 2;
                customPaint = new CustomPaint(xc, yc, new Point2D.Double(0, DIA / 2),
                        DIA / 2, BORDER, colorIn, colorOut);
                g2.setPaint(customPaint);
                eIn = new Ellipse2D.Double(width - PAD - DIA, height - PAD - DIA, DIA, DIA);
                eOut = new Ellipse2D.Double(width - PAD - DIA - BORDER,
                        height - PAD - DIA - BORDER, DIA + 2 * BORDER, DIA + 2 * BORDER);
                arcBorder = getArcArea(eIn, eOut, 270.0);
                g2.fill(arcBorder);
        }
    }

    private void calculateArcOrigins() {
        neOrigin = new Point2D.Double(width - PAD - DIA / 2, PAD + DIA / 2);
        nwOrigin = new Point2D.Double(PAD + DIA / 2, PAD + DIA / 2);
        swOrigin = new Point2D.Double(PAD + DIA / 2, height - PAD - DIA / 2);
        seOrigin = new Point2D.Double(width - PAD - DIA / 2, height - PAD - DIA / 2);
    }

    private void calculateCardinalDiagonals() {
        neDiag = new Point2D.Double(neOrigin.getX()
                + DIA * Math.cos(Math.toRadians(45)) / 2,
                neOrigin.getY() - DIA * Math.sin(Math.toRadians(45)) / 2);
        nwDiag = new Point2D.Double(nwOrigin.getX()
                + DIA * Math.cos(Math.toRadians(135)) / 2,
                nwOrigin.getY() - DIA * Math.sin(Math.toRadians(135)) / 2);
        swDiag = new Point2D.Double(swOrigin.getX()
                + DIA * Math.cos(Math.toRadians(225)) / 2,
                swOrigin.getY() - DIA * Math.sin(Math.toRadians(225)) / 2);
        seDiag = new Point2D.Double(seOrigin.getX()
                + DIA * Math.cos(Math.toRadians(315)) / 2,
                seOrigin.getY() - DIA * Math.sin(Math.toRadians(315)) / 2);
    }

    public Dimension getInnerSize() {
        return new Dimension((int) nwOrigin.distance(neOrigin),
                (int) nwOrigin.distance(swOrigin));
    }
}

class ShadowSelector extends JPanel {

    private static final long serialVersionUID = 1L;
    private ShadeOptionsPanel soPanel;
    private String[] directions = {"northeast", "northwest", "southwest", "southeast"};

    public ShadowSelector(ShadeOptionsPanel sop) {
        soPanel = sop;

        final SpinnerListModel model = new SpinnerListModel(directions);
        model.setValue(directions[3]);
        JSpinner spinner = new JSpinner(model);
        spinner.setPreferredSize(new Dimension(90, spinner.getPreferredSize().height));
        spinner.addChangeListener(new ChangeListener() {

            @Override
            public void stateChanged(ChangeEvent e) {
                String value = (String) model.getValue();
                soPanel.shadowVertex = model.getList().indexOf(value);
                soPanel.repaint();
            }
        });
        add(new JLabel("shadow vertex", JLabel.RIGHT));
        add(spinner);
    }
}

class CustomPaint implements Paint {

    Point2D originP, radiusP;
    int radius, border;
    Color colorIn, colorOut;

    public CustomPaint(int x, int y, Point2D radiusP,
            int radius, int border,
            Color colorIn, Color colorOut) {
        originP = new Point2D.Double(x, y);
        this.radiusP = radiusP;
        this.radius = radius;
        this.border = border;
        this.colorIn = colorIn;
        this.colorOut = colorOut;
    }

    @Override
    public PaintContext createContext(ColorModel cm, Rectangle deviceBounds, Rectangle2D userBounds, AffineTransform xform, RenderingHints hints) {
        Point2D xformOrigin = xform.transform(originP, null), xformRadius = xform.deltaTransform(radiusP, null);
        return new CustomPaintContext(xformOrigin, xformRadius, radius, border, colorIn, colorOut);
    }

    @Override
    public int getTransparency() {
        int alphaIn = colorIn.getAlpha();
        int alphaOut = colorOut.getAlpha();
        return (((alphaIn & alphaOut) == 0xff) ? OPAQUE : TRANSLUCENT);
    }
}

class CustomPaintContext implements PaintContext {

    Point2D originP, radiusP;
    Color colorIn, colorOut;
    int radius, border;

    public CustomPaintContext(Point2D originP, Point2D radiusP, int radius, int border, Color colorIn, Color colorOut) {
        this.originP = originP;
        this.radiusP = radiusP;
        this.radius = radius;
        this.border = border;
        this.colorIn = colorIn;
        this.colorOut = colorOut;
    }

    @Override
    public void dispose() {
    }

    @Override
    public ColorModel getColorModel() {
        return ColorModel.getRGBdefault();
    }

    @Override
    public Raster getRaster(int x, int y, int w, int h) {
        WritableRaster raster = getColorModel().createCompatibleWritableRaster(w, h);
        int[] data = new int[w * h * 4];
        for (int j = 0; j < h; j++) {
            for (int i = 0; i < w; i++) {
                double distance = originP.distance(x + i, y + j);
                double r = radiusP.distance(radius, radius);
                double ratio = distance - r < 0 ? 0.0 : (distance - r) / border;
                if (ratio > 1.0) {
                    ratio = 1.0;
                }
                int base = (j * w + i) * 4;
                data[base + 0] = (int) (colorIn.getRed() + ratio * (colorOut.getRed() - colorIn.getRed()));
                data[base + 1] = (int) (colorIn.getGreen() + ratio * (colorOut.getGreen() - colorIn.getGreen()));
                data[base + 2] = (int) (colorIn.getBlue() + ratio * (colorOut.getBlue() - colorIn.getBlue()));
                data[base + 3] = (int) (colorIn.getAlpha() + ratio * (colorOut.getAlpha() - colorIn.getAlpha()));
            }
        }
        raster.setPixels(0, 0, w, h, data);
        return raster;
    }
}

import java.awt.*；
导入java.awt.geom.*；
导入java.awt.image.ColorModel；
导入java.awt.image.graster；
导入java.awt.image.WritableRaster；
导入javax.swing.*；
导入javax.swing.event.*；
公开课小组2测试{
公共静态void main（字符串[]args）{
SwingUtilities.invokeLater（新的Runnable（）{
@凌驾
公开募捐{
ShadeOptionsPanel shadeOptions=新的ShadeOptionsPanel（）；
ShadowSelector ShadowSelector=新的ShadowSelector（shadeOptions）；
//ComponentSource ComponentSource=新的ComponentSource（shadeOptions）；
JFrame f=新JFrame（“带阴影的圆形概念演示”）；
f、 setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
f、 添加（阴影选择器，“北”）；
f、 添加（shadeOptions）；
//f、 添加（组件来源，“南”）；
f、 设置大小（300200）；
f、 设置位置（150150）；
f、 setVisible（真）；
}
});
}
专用面板2Test（）{
}
}
类ShadeOptionsPanel扩展了JPanel{
私有静态最终长serialVersionUID=1L；
专用最终内部焊盘，直径，边框；
私密的颜色着色，着色；
私人int xc，yc；
私人Ellipse2D eIn，eOut；
私有渐变绘制渐变；
私人定制油漆；
私人区域边界；
私人int宽度、高度；
private Point2D neOrigin、nwOrigin、swOrigin、seOrigin、neDiag、nwDiag、swDiag、seDiag；
私人最终静态int东北=0，西北=1，西南=2，东南=3；
公共顶点=3；
公共ShadeOptionsPanel（）{
PAD=25；
直径=75；
边界=10；
colorIn=Color.black；
colorOut=getBackground（）；
}
@凌驾
公共组件（图形g）{
超级组件（g）；
图形2d g2=（图形2d）g；
g2.setRenderingHint（renderingHits.KEY\u ANTIALIASING，renderingHits.VALUE\u ANTIALIAS\u ON）；
宽度=getWidth（）；
高度=getHeight（）；
g2.drawRoundRect（衬垫，衬垫，宽度-2*衬垫，高度-2*衬垫，直径，直径）；
calculateArcOrigins（）；
计算心对角线（）；
drawVertexArc（g2，阴影顶点）；
开关（阴影顶点）{
案例东北：
北侧（g2）；
抽屉背面（g2）；
xc=PAD+DIA/2；//绘制西北弧
yc=焊盘+直径/2；
customPaint=新的customPaint（xc、yc、新点2D.双（0，直径/2），
直径/2，边框，着色，着色）；
g2.setPaint（自定义绘制）；
eIn=getInnerEllipse（nwOrigin，nwDiag）；
Out=getOuterEllipse（nwOrigin，nwDiag）；
arcBorder=getArcArea（eIn，eOut，90.0）；
g2.填充（弧形边界）；
xc=宽度-焊盘-直径/2；//绘制东南弧
yc=高度-衬垫-直径/2；
customPaint=新的customPaint（xc、yc、新点2D.双（0，直径/2），
直径/2，边框，着色，着色）；
g2.setPaint（自定义绘制）；
eIn=getInnerEllipse（seOrigin，seDiag）；
eOut=getOuterEllipse（seOrigin，seDiag）；
arcBorder=getArcArea（eIn，eOut，270.0）；
g2.填充（弧形边界）；
打破
案例西北：
北侧（g2）；
西侧（g2）；
xc=宽度-焊盘-直径/2；//绘制东北弧
yc=焊盘+直径/2；
customPaint=新的customPaint（xc、yc、新点2D.双（0，直径/2），
直径/2，边框，着色，着色）；
g2.setPaint（自定义绘制）；
eIn=getInnerEllipse（尼日利亚尼奥里金）；
Out=getOuterEllipse（尼地亚尼奥里金）；
arcBorder=getArcArea（eIn，eOut，0.0）；
g2.填充（弧形边界）；
xc=PAD+DIA/2；//画西南弧
yc=高度-衬垫-直径/2；
customPaint=新的customPaint（xc、yc、新点2D.双（0，直径/2），
直径/2，边框，着色，着色）；
g2.setPaint（自定义绘制）；
eIn=getInnerEllipse（swOrigin，swDiag）；
eOut=getOuterEllipse（宣誓、swDiag）；
arcBorder=getArcArea（eIn，eOut，180.0）；