Java 当我在JPanel上绘制背景图像时，它在Windows下的行为与在Linux下的不同

我正在为工作开发一个程序（注意：我不能共享完整的代码，因为它在很大程度上是受保护的工作产品，但我将尽我所能共享所有代码）。在应用程序中，我有一个JPanel，其中应用了背景图像。其中一些面板还附带了鼠标侦听器&我的管理层希望有一个可视的线索，可以单击面板来启动操作。为此，我将一个透明的JPanel与背景图像叠加在JPanel的顶部，并在其上附加一个鼠标侦听器，以关闭鼠标插入/退出的事件。当鼠标进入图像面板时，覆盖面板将从透明切换到半透明，并在鼠标退出时返回

在Linux下，这一点非常有效。在Windows下。。。幸好我是秃头，所以我不能把头发扯下来。似乎正在发生的是，当我移动鼠标时，某种类型的图像缓存正在发生，而mouseEnter事件导致鼠标在一秒钟前的任何内容都被绘制到框架中；i、 e.如果我将鼠标放在GUI上附近的按钮上，然后将鼠标放在面板上，我将看到按钮与周围的GUI一起出现在面板中

图像面板包含在不透明的JInternalFrame中

另一件需要注意的事情是，如果我在应用程序中做了一些会导致图像更改的事情（例如，从JComboBox中进行新的选择），则图像会按预期重新绘制。不管问题是什么，它似乎与突出显示和图像如何重新绘制有关

我不应该为Windows做什么

提前谢谢

。Start.png是面板打开时在两个操作系统中的外观。GoodMouseEnter.png是Linux下mouseEnter事件的样子。BadMouseEnter.png和badMouseExit.png是Windows下的外观

这是我用来创建图像面板的类（编辑：这个示例是自包含的）：

导入java.awt.Color；
导入java.awt.Dimension；
导入java.awt.Graphics；
导入java.awt.Graphics2D；
导入java.awt.Toolkit；
导入java.awt.event.MouseEvent；
导入java.awt.event.MouseListener；
导入java.awt.image.buffereImage；
导入java.awt.image.ImageObserver；
导入java.io.IOException；
导入java.net.MalformedURLException；
导入java.net.URL；
导入java.util.logging.Level；
导入java.util.logging.Logger；
导入javax.imageio.imageio；
导入javax.swing.JFrame；
导入javax.swing.JPanel；
公共类图像测试{
JFrame frm=null；
ImagePanel imgP=null；
publicstaticvoidmain（字符串[]args）引发畸形的DurLexException
{
ImageTest it=新的ImageTest（）；
it.initialize（）；
}
public void initialize（）引发畸形的DurException
{
String path=“file:/C:/CylinderTank.png”；
URL imagePath=新URL（路径）；
System.out.println（imagePath.toString（））；
frm=新的JFrame（）；
imgP=新的ImagePanel（真）；
int fW=500；
int fH=700；
int pW=450；
int pH=650；
frm.setLayout（空）；
frm.setPreferredSize（新尺寸（fW，fH））；
frm.设置尺寸（fW、fH）；
imgP.getFilterPanel（）.addMouseListener（新的PanelListener（））；
imgP.使用定制尺寸（pW，pH）；
imgP.setImageURL（imagePath）；
imgP.立根（0,0,pW，pH）；
frm.add（imgP）；
frm.pack（）；
frm.setVisible（真）；
}
私有类PanelListener实现MouseListener{
公共PanelListener（）{}
@凌驾
公共无效mouseClicked（MouseEvent e）{}
@凌驾
public void mousePressed（MouseEvent e）{}
@凌驾
公共无效MouseEvent e{}
@凌驾
公共无效鼠标事件（鼠标事件e）
{
imgP.highlightImage（真）；
imgP.repaint（）；
}
@凌驾
公共无效mouseExited（MouseEvent e）
{
imgP.highlightImage（假）；
imgP.repaint（）；
}
}    
}
@抑制警告（“串行”）
类ImagePanel扩展JPanel实现ImageObserver{
私人最终JPanel filterPanel；
私有缓冲图像；
私人规模；
私人最终工具包；
private boolean highlight=false；
专用URL图像路径；
私人int imgW、imgH；
私有最终颜色blueFilter=新颜色（0,0,255,38）；
私有最终颜色redFilter=新颜色（255,0,0,38）；
专用最终颜色绿色过滤器=新颜色（0,255,0,38）；
专用最终颜色清除=新颜色（0,0,0,0）；
专用最终颜色bgColor=新颜色（116、169、255、255）；
私有布尔值customSize=false；
公共图像面板（布尔不透明）
{
超级（）；
this.kit=Toolkit.getDefaultToolkit（）；
setLayout（空）；
设置不透明（不透明）；
挫折背景（bgColor）；
filterPanel=新的JPanel（）；
过滤板后退地面（清除）；
}
公共图像面板（URL图像路径，布尔不透明）
{
超级（）；
this.imagePath=imagePath；
this.kit=Toolkit.getDefaultToolkit（）；
setLayout（空）；
设置不透明（不透明）；
挫折背景（bgColor）；
filterPanel=新的JPanel（）；
过滤板后退地面（清除）；
readImage（）；
}
@凌驾
受保护组件（图形g）
{
Graphics2D g2D=（Graphics2D）g；
如果（突出显示）
过滤器面板立根地面（蓝过滤器）；
其他的
过滤板后退地面（清除）；
int X=0，Y=0；
如果（图像！=null）
{
image.flush（）；
试剂盒准备图像（图-1，-1，本）；
如果（自定义大小）
{
X=（面板尺寸.宽度-imgW）/2；
Y=（面板尺寸.高度-imgH）/2；
}
if（isOpaque（））
g2D.drawImage（图像，X，Y，bgColor，this）；
其他的
g2D.drawImage（图像，X，Y，this）；
}
其他的
超级油漆组件（g2D）；
}
公共空白高光图像（布尔高光）
{
high=highlight；
}
私有void readImage（）
{
尝试
{
image=ImageIO.read（imagePath）；
imgW=image.g
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Toolkit;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.image.BufferedImage;
import java.awt.image.ImageObserver;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class ImageTest {
JFrame frm = null;
ImagePanel imgP = null;

public static void main(String[] args) throws MalformedURLException 
{
    ImageTest it = new ImageTest();
    it.initialize();
}

public void initialize() throws MalformedURLException
{
    String path = "file:/C:/CylinderTank.png";
    URL imagePath = new URL(path);
    System.out.println(imagePath.toString());
    frm = new JFrame();
    imgP = new ImagePanel(true);
    int fW = 500;
    int fH = 700;
    int pW = 450;
    int pH = 650;

    frm.setLayout(null);
    frm.setPreferredSize(new Dimension(fW,fH));
    frm.setSize(fW,fH);

    imgP.getFilterPanel().addMouseListener(new PanelListener());
    imgP.useCustomSizing(pW, pH);
    imgP.setImageURL(imagePath);
    imgP.setBounds(0, 0, pW, pH);

    frm.add(imgP);

    frm.pack();
    frm.setVisible(true);
}

private class PanelListener implements MouseListener {

    public PanelListener() {        }
    @Override
    public void mouseClicked(MouseEvent e) {        }
    @Override
    public void mousePressed(MouseEvent e) {        }
    @Override
    public void mouseReleased(MouseEvent e) {        }
    @Override
    public void mouseEntered(MouseEvent e) 
    {
        imgP.highlightImage(true);
        imgP.repaint();
    }
    @Override
    public void mouseExited(MouseEvent e) 
    {
        imgP.highlightImage(false);
        imgP.repaint();
    }
}    
}



@SuppressWarnings("serial")
class ImagePanel extends JPanel implements ImageObserver {
private final JPanel filterPanel;
private BufferedImage image;
private Dimension panelSize;
private final Toolkit kit;
private boolean highlight = false;
private URL imagePath;
private int imgW, imgH;
private final Color blueFilter = new Color(0, 0, 255, 38);
private final Color redFilter = new Color(255, 0, 0, 38);
private final Color greenFilter = new Color(0, 255, 0, 38);
private final Color clear = new Color(0, 0, 0, 0);
private final Color bgColor = new Color(116, 169, 255, 255);
private boolean customSize = false;

public ImagePanel(boolean opaque)
{
    super();
    this.kit = Toolkit.getDefaultToolkit();
    setLayout(null);
    setOpaque(opaque);
    setBackground(bgColor);
    filterPanel = new JPanel();
    filterPanel.setBackground(clear);
}

public ImagePanel(URL imagePath, boolean opaque)
{
    super();
    this.imagePath = imagePath;
    this.kit = Toolkit.getDefaultToolkit();
    setLayout(null);
    setOpaque(opaque);
    setBackground(bgColor);
    filterPanel = new JPanel();
    filterPanel.setBackground(clear);

    readImage();

}

@Override
protected void paintComponent(Graphics g)
{
    Graphics2D g2D = (Graphics2D) g;

    if (highlight)
        filterPanel.setBackground(blueFilter);
    else
        filterPanel.setBackground(clear);

    int X = 0, Y = 0;
    if (image != null)
    {
        image.flush();
        kit.prepareImage(image, -1, -1, this);

        if (customSize)
        {
            X = (panelSize.width - imgW) / 2;
            Y = (panelSize.height - imgH) / 2;
        }

        if (isOpaque())
            g2D.drawImage(image, X, Y, bgColor, this);
        else
            g2D.drawImage(image, X, Y, this);
    }
    else
        super.paintComponent(g2D);
}

public void highlightImage(boolean highlight)
{
    this.highlight = highlight;

}

private void readImage()
{
    try
    {
        image = ImageIO.read(imagePath);
        imgW = image.getWidth();
        imgH = image.getHeight();

        if (customSize)
            panelSize = getPreferredSize();
        else
            panelSize = new Dimension(imgW, imgH);

        setPreferredSize(panelSize);
        setMinimumSize(panelSize);
        setMaximumSize(panelSize);

        int X = (panelSize.width - imgW) / 2;
        int Y = (panelSize.height - imgH) / 2;
        filterPanel.setBounds(X, Y, imgW, imgH);

        add(filterPanel);
    }
    catch (IOException ex)  
    {
        Logger.getLogger(ImagePanel.class.getName()).log(Level.SEVERE, null, ex);
    }
}


public void setImageURL(URL img)
{
    this.imagePath = img;
    readImage();
}

public Dimension getDisplayedImageSize()
{
    if (image == null)
        return null;

    return new Dimension(imgW, imgH);
}

public JPanel getFilterPanel()
{
    return filterPanel;
}

public void useCustomSizing(int W, int H)
{
    if (W < 0)
        W = getPreferredSize().width;
    if (H < 0)
        H = getPreferredSize().height;

    if ((W>0) || (H>0))
        customSize = true;

    Dimension cDim = new Dimension(W,H);
    setPreferredSize(cDim);
    setMinimumSize(cDim);
    setMaximumSize(cDim);

    repaint();
}
}//end class ImagePanel

@Override
protected void paintComponent(Graphics g) {
    Graphics2D g2D = (Graphics2D) g;
    super.paintComponent(g2D);

    int X = 0, Y = 0;
    if (image != null) {

        if (customSize) {
            X = (panelSize.width - imgW) / 2;
            Y = (panelSize.height - imgH) / 2;
        }

        g2D.drawImage(image, X, Y, this);
    }


    if (highlight) {
        g2D.setColor(blueFilter);
        g2D.fillRect(X, Y, image.getWidth(), image.getHeight());
    }

}

import java.awt.Color;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.HeadlessException;
import java.awt.Rectangle;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

public class MouseOverTest {

    public static void main(String[] args) {
        new MouseOverTest();
    }

    public MouseOverTest() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
                    ex.printStackTrace();
                }

                try {
                    BufferedImage background = ImageIO.read(new File("C:\\hold\\thumbnails\\_MTCGAC__Pulling_Cords_by_Dispozition.png"));

                    JFrame frame = new JFrame("Testing");
                    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                    frame.add(new TestPane(background));
                    frame.pack();
                    frame.setLocationRelativeTo(null);
                    frame.setVisible(true);
                } catch (IOException exp) {
                    exp.printStackTrace();
                }
            }
        });
    }

    public static class TestPane extends JPanel {

        protected static final Color BLUE_FILTER = new Color(0, 0, 255, 38);

        private BufferedImage background;
        private Rectangle imageBounds;
        private boolean mouseInTheHouse;

        public TestPane(BufferedImage background) {
            this.background = background;
            MouseAdapter ma = new MouseAdapter() {
                @Override
                public void mouseMoved(MouseEvent e) {
                    mouseInTheHouse = getImageBounds().contains(e.getPoint());
                    repaint();
                }

                @Override
                public void mouseExited(MouseEvent e) {
                    mouseInTheHouse = false;
                    repaint();
                }

            };
            addMouseMotionListener(ma);
            addMouseListener(ma);
        }

        @Override
        public Dimension getPreferredSize() {
            return background == null ? new Dimension(200, 200) : new Dimension(background.getWidth(), background.getHeight());
        }

        @Override
        public void invalidate() {
            imageBounds = null;
            super.invalidate();
        }

        protected Rectangle getImageBounds() {

            if (imageBounds == null) {

                if (background != null) {

                    int x = (getWidth() - background.getWidth()) / 2;
                    int y = (getHeight() - background.getHeight()) / 2;
                    imageBounds = new Rectangle(x, y, background.getWidth(), background.getHeight());

                } else {

                    imageBounds = new Rectangle(0, 0, 0, 0);

                }

            }

            return imageBounds;

        }

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2d = (Graphics2D) g.create();
            Rectangle bounds = getImageBounds();
            if (background != null) {
                g2d.drawImage(background, bounds.x, bounds.y, this);
            }
            if (mouseInTheHouse) {
                g2d.setColor(BLUE_FILTER);
                g2d.fill(bounds);
            }
            g2d.dispose();
        }

    }

}