Java Swing - 在透明的JPanel上应用组件的透明度

Question

我正在创建一个支持透明度的 JPanel，但是遇到了一个问题，即不确定如何将同一级别的透明度应用于添加到此面板的所有 Component。 我目前的代码：

package de.uebertreiberman.project.swing;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Rectangle;

import javax.swing.JPanel;

@SuppressWarnings("serial")
public class JTransparancyPanel extends JPanel {

    float opacity = 1.0f;

    /**Constructor for JTransparentPanel
     */
    public JTransparancyPanel()
    {
        super();
        this.setOpaque(false);
    }

    /**Getter for opacity value of panel
     * 
     * @return float containing opacity value of frame (0-1)
     */
    public float getOpacity()
    {
        return opacity;
    }

    /**Setter for opacity value of panel
     * 
     * @param value as float for opacity of frame (0-1)
     */
    public void setOpacity(float value)
    {
        opacity = value;
        repaint();
    }

    /**Converts opacity value (0-1) to opacity color (0-255)
     * 
     * @param opacity as float opacity value (0-1)
     * @return integer containing converted opacity value (0-255)
     */
    public static int getOpacityColor(float opacity)
    {
        return (int)(opacity * 255);
    }

    /**Converts opacity color (0-255) to opacity value (0-1)
     * 
     * @param opacity as integer value (0-255)
     * @return float containing converted opacity value (0-1)
     */
    public static float getOpacityValue(int opacity)
    {
        //Returns more or less the correct, capped value
        //Just ignore it, it works, leave it :D
        return capFloat((3.9216f*opacity)/1000f, 0.0f, 1.0f);
    }

    /**Returns float capped between minimum and maximum value
     * 
     * @param value as original value
     * @param min as minimum cap value
     * @param max as maximum cap value
     * @return float containing capped value
     */
    public static float capFloat(float value, float min, float max)
    {
        if(value < min) value = min;
            else if(value > max) value = max;

        return value;
    }

    /**Merges color and opacity to new color
     * 
     * @param bg as color for old color, only RGB will be used from that
     * @return color with RGB from bg and A from opacity of frame
     */
    Color getTransparencyColor(Color bg)
    {
        return new Color(getOpacityValue(bg.getRed()), getOpacityValue(bg.getGreen()), getOpacityValue(bg.getBlue()), opacity);
    }

    @Override
    public void paintComponent(Graphics g)
    {
        //Draw transparent background before painting other Components
        g.setColor(getTransparencyColor(getBackground()));
        Rectangle r = g.getClipBounds();
        g.fillRect(r.x, r.y, r.width, r.height);

        //Paint other components
        super.paintComponent(g);
    }
}

重要的部分基本上在最后，我覆盖了paintComponent(Graphics g)方法。

我只是取backgroundcolor，应用透明度并设置它。

现在我想让这个面板的所有子组件也变成透明的，但我不太确定最有效的方法是什么。

你有什么建议吗？

- Uebertreiberman

---

这很困难，如果不覆盖相应组件的paint/paintComponent方法。没有任何东西可以阻止子组件肆意地填充其区域为纯色、不透明的颜色。可以尝试一些技巧，将子组件绘制到图像中，然后使用适当的不透明度绘制此图像。我会尝试一下，但可能有点棘手。 - Marco13

我还没有尝试过，今天也没有时间，但是你不能只获取组件(Component[] components = jpanel.getComponents();)，遍历它们并使用getGraphics().setBackgroundColour()设置它们的背景吗？ - MrB

Answer 1

我找到了一个解决方案 - 基本上就是我在评论中提到的：面板并没有真正地绘制在屏幕上。相反，它被绘制成一张图片，并且这张图片使用适当的AlphaComposite进行绘制。

（滑块可用于设置面板的不透明度）

尽管这个解决方案简单、通用，基本上应该适用于所有子组件，但有一件事情我不喜欢：必须调整RepaintManager。为了确保面板的不透明度得到应用（子组件不会独立绘制，并以其全部不透明度绘制），当子组件被重新绘制时，重绘管理器必须触发整个组件的重绘。我认为应该有一种解决方案可以避免这个问题（例如，在面板上覆盖getGaphics可能是适当的极少数情况之一），但无济于事。也许那些经常出谋划策的人（如camickr、Hovercraft等）能够找到更优雅、更简洁的解决方案。

在此之前，以下是作为MCVE的代码：

import java.awt.AlphaComposite;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;

import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JSlider;
import javax.swing.JTree;
import javax.swing.RepaintManager;
import javax.swing.SwingUtilities;

public class TransparencyPanelTest
{
    public static void main(String[] args)
    {
        SwingUtilities.invokeLater(() -> createAndShowGui());
    }

    private static void createAndShowGui()
    {
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.getContentPane().setLayout(new BorderLayout());

        OpacityPanel opacityPanel = new OpacityPanel();

        opacityPanel.setLayout(new BorderLayout());
        opacityPanel.add(new JLabel("Label"), BorderLayout.NORTH);
        opacityPanel.add(new JTree(), BorderLayout.CENTER);
        opacityPanel.add(new JButton("Button"), BorderLayout.SOUTH);

        f.getContentPane().add(opacityPanel, BorderLayout.CENTER);

        JSlider slider = new JSlider(0, 100, 50);
        slider.addChangeListener(e -> 
            opacityPanel.setOpacity(slider.getValue() / 100.0f));
        f.getContentPane().add(slider, BorderLayout.SOUTH);

        f.setSize(500,500);
        f.setLocationRelativeTo(null);
        f.setVisible(true);
    }

}

class OpacityPanel extends JPanel
{
    static
    {
        RepaintManager.setCurrentManager(new RepaintManager()
        {
            @Override
            public void addDirtyRegion(
                JComponent c, int x, int y, int w, int h)
            {
                Component cc = c;
                while (cc != null)
                {
                    if (cc instanceof OpacityPanel)
                    {
                        OpacityPanel p = (OpacityPanel)cc;
                        super.addDirtyRegion(
                            p, 0, 0, p.getWidth(), p.getHeight());
                    }
                    cc = cc.getParent();
                }
                super.addDirtyRegion(c, x, y, w, h);
            }
        });
    }
    private float opacity = 0.5f;
    private BufferedImage image;

    public OpacityPanel()
    {
        setOpaque(false);
    }

    public void setOpacity(float opacity)
    {
        this.opacity = Math.max(0.0f, Math.min(1.0f, opacity));
        repaint();
    }

    private void updateImage()
    {
        int w = Math.min(1, getWidth());
        int h = Math.min(1, getHeight());
        if (image == null || image.getWidth() != w || image.getHeight() != h)
        {
            image = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
        }
        Graphics2D g = image.createGraphics();
        g.setColor(new Color(0,0,0,0));
        g.setComposite(AlphaComposite.SrcOver);
        g.fillRect(0, 0, w, h);
        g.dispose();
    }

    @Override
    protected void paintComponent(Graphics gr)
    {
        updateImage();
        Graphics2D imageGraphics = image.createGraphics();
        super.paintComponent(imageGraphics);
        imageGraphics.dispose();

        Graphics2D g = (Graphics2D) gr;
        g.setComposite(AlphaComposite.getInstance(
            AlphaComposite.SRC_OVER, opacity));
        g.drawImage(image, 0, 0, null);
    }

}

- Marco13

---

很酷，感谢您的快速回复。 我觉得现在对我来说有点晚了，无法完全理解这个解决方案，但我认为我知道你在做什么。我明天会尝试将其实现到我的代码中。 我还会更详细地了解RepaintManager，因为我现在对它的工作方式很感兴趣。 再次感谢，你帮了我很多！ - Uebertreiberman

@Uebertreiberman 不要太急于接受答案的速度;-) 也许你应该等一会儿，也许其他人会想出更好的解决方案。我仍然认为应该有一个更简单的方法而不需要repaint manager，但是Swing绘图机制在幕后有时相当复杂，这看起来像是实现所需目标的简单方法。 - Marco13

Answer 2

第三楼的回答很棒，但我认为我们不能重写重绘管理器，我们可以将面板设置为非不透明，或在所需设置中将子组件设置为非不透明，如下所示。

    for (Component c : panel.getComponents()) {
        ((JComponent)c).setOpaque(false);
    }

- VsRoom