Java 什么样的巫术是必要的，以使玻璃窗格可见和有效的一个JInternalFrame？

我有一个项目，我使用

JDesktopPane

作为主要应用程序，使用一系列

JInternalFrame

s进行一系列独立分析

某些分析非常耗时，因此我在SwingWorker上运行它们，但我想禁用GUI（因此没有操作排队），并通知用户某些操作正在进行，这是正常的

在此之前，我使用了一个定制的玻璃材质窗格玻璃，它以前工作得很好。现在我遇到了一些问题，使用与以前相同的类。具体来说，glassPane截取用户输入，但没有可见的视觉提示，这使我认为glassPane从未调用

paintComponent（）

为了确保我在谷歌上搜索到了另一个“请等待玻璃窗格”概念的实现（称为），但实际上并没有成功。在尝试调试该问题时，我意识到当我启动/激活我的glassPane时，默认情况下它是无效的，并且不会自行验证

如果我在激活glassPane后在

JInternalFrame

上特别调用

validate（）

，则根据glassPane的属性，它看起来是有效的和可见的，但我在屏幕上看不到任何内容（glassPane的两种实现都具有基于颜色和文本的功能，用户应该可以立即看到）

编辑：

下面是相关的代码片段，从更大的方案中提取出来，形成一个最小的、自包含的示例（上面提到的

DisabledGlassPane

类除外，为简洁起见省略）。当我运行下面的

DesktopFrame

类，并单击开始计算的按钮时，光标会变为等待模式，但是屏幕不会变灰，并且不会显示给用户的消息，因此我对

paintComponent

的怀疑从未真正被调用

我主要想知道我是否犯了一个明显的错误，因为我没有GUI编程和Swing方面的经验

import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.concurrent.ExecutionException;

import javax.swing.JButton;
import javax.swing.JDesktopPane;
import javax.swing.JFrame;
import javax.swing.JInternalFrame;
import javax.swing.SwingWorker;
import javax.swing.event.InternalFrameEvent;
import javax.swing.event.InternalFrameListener;


public class DesktopFrame extends JFrame implements InternalFrameListener{

    private JDesktopPane dpane;
    private JInternalFrame f;
    static DisabledGlassPane gp = new DisabledGlassPane();

    public DesktopFrame()  {
        dpane = new javax.swing.JDesktopPane();
        dpane.setPreferredSize(new java.awt.Dimension(1020, 778));
        setContentPane(dpane);
        addFrame();
        pack();
    }

    public JInternalFrame addFrame(){
        f = new JInternalFrame("test");
        f.setGlassPane(gp);
        f.addInternalFrameListener(this);
        f.setLayout(new GridLayout());
        f.setPreferredSize(new java.awt.Dimension(400,300));
        f.add(new javax.swing.JLabel("something something"));
        f.add(new javax.swing.JTextArea(10, 10));
        javax.swing.JButton but = new JButton("click me!");
        but.setPreferredSize(new java.awt.Dimension(100,50));
        but.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                gp.activate("Please wait...");
                SwingWorker<Void, Void> worker = new SwingWorker<Void, Void>() {
                @Override
                protected Void doInBackground() throws Exception {
                    for(float i=-3000; i < 3000; i = i + 0.01f){
                        double exp = Math.pow(2,i);
                        double fac = Math.pow(i, 2);
                        System.out.println(exp/fac);
                    }                                   
                    return null;
                    }
                };

                worker.execute();
                try {
                    if(worker.get() == null)
                        gp.deactivate();            

                } catch (InterruptedException | ExecutionException e1) {
                    e1.printStackTrace();
                }

            }
        });
        f.add(but);
        f.setVisible(true);
        f.pack();
        dpane.add(f);

        try {
            f.setSelected(true);
        } catch (java.beans.PropertyVetoException e) {
            e.printStackTrace();
        }
        dpane.repaint();
        return f;
    }

    public static void main(String args[]) {
        /* Create and display the form */
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                DesktopFrame df = new DesktopFrame();                   
                df.setLocationRelativeTo(null);
                df.setVisible(true);
                df.setDefaultCloseOperation(EXIT_ON_CLOSE);             
            }
        });
    }

    @Override
    public void internalFrameOpened(InternalFrameEvent e) {}
    @Override
    public void internalFrameClosing(InternalFrameEvent e) {}
    @Override
    public void internalFrameClosed(InternalFrameEvent e) {}
    @Override
    public void internalFrameIconified(InternalFrameEvent e) {}
    @Override
    public void internalFrameDeiconified(InternalFrameEvent e) {}
    @Override
    public void internalFrameActivated(InternalFrameEvent e) {}
    @Override
    public void internalFrameDeactivated(InternalFrameEvent e) {}
}

导入java.awt.GridLayout；
导入java.awt.event.ActionEvent；
导入java.awt.event.ActionListener；
导入java.util.concurrent.ExecutionException；
导入javax.swing.JButton；
导入javax.swing.JDesktopPane；
导入javax.swing.JFrame；
导入javax.swing.JInternalFrame；
导入javax.swing.SwingWorker；
导入javax.swing.event.InternalFrameEvent；
导入javax.swing.event.InternalFrameListener；
公共类DesktopFrame扩展JFrame实现InternalFrameListener{
私人JDesktopPane dpane；
私人金泰尔纳夫；
静态DisabledClassPane gp=新建DisabledClassPane（）；
公共桌面框架（）{
dpane=newjavax.swing.JDesktopPane（）；
setPreferredSize（新java.awt.Dimension（1020778））；
setContentPane（dpane）；
addFrame（）；
包装（）；
}
公共JInternalFrame addFrame（）{
f=新的JInternalFrame（“测试”）；
f、 玻璃纤维板（gp）；
f、 addInternalFrameListener（此）；
f、 setLayout（新的GridLayout（））；
f、 setPreferredSize（新java.awt.Dimension（400300））；
f、 添加（newjavax.swing.JLabel（“某物”）；
f、 添加（newjavax.swing.JTextArea（10,10））；
javax.swing.JButton but=newjbutton（“单击我！”）；
但是.setPreferredSize（新的java.awt.Dimension（100,50））；
但是.addActionListener（新ActionListener（）{
@凌驾
已执行的公共无效操作（操作事件e）{
gp.激活（“请稍候…”）；
SwingWorker worker=新SwingWorker（）{
@凌驾
受保护的Void doInBackground（）引发异常{
对于（浮动i=-3000；i<3000；i=i+0.01f）{
双经验=数学功率（2，i）；
双因子=数学功率（i，2）；
系统输出打印项次（exp/fac）；
}                                   
返回null；
}
};
worker.execute（）；
试一试{
if（worker.get（）==null）
gp.deactivate（）；
}捕获（中断异常|执行异常e1）{
e1.printStackTrace（）；
}
}
});
f、 添加（但）；
f、 setVisible（真）；
f、 包装（）；
dpane.添加（f）；
试一试{
f、 已选择（正确）；
}catch（java.beans.PropertyVetoException）{
e、 printStackTrace（）；
}
dpane.repaint（）；
返回f；
}
公共静态void main（字符串参数[]）{
/*创建并显示表单*/
invokeLater（new Runnable（））{
公开募捐{
DesktopFrame df=新的DesktopFrame（）；
df.setLocationRelativeTo（空）；
df.setVisible（真）；
df.setDefaultCloseOperation（关闭时退出）；
}
});
}
@凌驾
public void internalFrameOpened（InternalFrameEvent e）{}
@凌驾
公共无效internalFrameClosing（InternalFrameEvent e）{}
@凌驾
公共无效internalFrameClosed（InternalFrameEvent e）{}
@凌驾
public void internalFrameIconified（InternalFrameEvent e）{}
@凌驾
公共无效internalFrameDeiconified（InternalFrameEvent e）{}
@凌驾
public void internalFrameActivated（InternalFrameEvent e）{}
@凌驾
public void internalFrameDeactivated（InternalFrameEvent e）{}
}

但是我想禁用GUI（因此没有操作排队），并通知用户某些操作正在进行，这是正常的

请查看，以获取您可能能够使用的通用解决方案。上述类别