Java JInternalFrame作为模态

我有以下代码：

import java.awt.AWTEvent;
import java.awt.ActiveEvent;
import java.awt.Component;
import java.awt.EventQueue;
import java.awt.MenuComponent;
import java.awt.event.MouseEvent;
import javax.swing.JInternalFrame;
import javax.swing.SwingUtilities;

public class modalInternalFrame extends JInternalFrame {

// indica si aquest es modal o no.
    boolean modal = false;

    @Override
    public void show() {
        super.show();
        if (this.modal) {
            startModal();
        }
    }

    @Override
    public void setVisible(boolean value) {
        super.setVisible(value);
        if (modal) {
            if (value) {
                startModal();
            } else {
                stopModal();
            }
        }
    }

    private synchronized void startModal() {

        try {
            if (SwingUtilities.isEventDispatchThread()) {
                EventQueue theQueue =
                        getToolkit().getSystemEventQueue();
                while (isVisible()) {
                    AWTEvent event = theQueue.getNextEvent();
                    Object source = event.getSource();
                    boolean dispatch = true;

                    if (event instanceof MouseEvent) {
                        MouseEvent e = (MouseEvent) event;
                        MouseEvent m =
                                SwingUtilities.convertMouseEvent((Component) e.getSource(), e, this);
                        if (!this.contains(m.getPoint()) && e.getID() != MouseEvent.MOUSE_DRAGGED) {
                            dispatch = false;
                        }
                    }

                    if (dispatch) {
                        if (event instanceof ActiveEvent) {
                            ((ActiveEvent) event).dispatch();
                        } else if (source instanceof Component) {
                            ((Component) source).dispatchEvent(
                                    event);
                        } else if (source instanceof MenuComponent) {
                            ((MenuComponent) source).dispatchEvent(
                                    event);
                        } else {
                            System.err.println(
                                    "Unable to dispatch: " + event);
                        }
                    }
                }
            } else {
                while (isVisible()) {
                    wait();
                }
            }
        } catch (InterruptedException ignored) {
        }

    }

    private synchronized void stopModal() {
        notifyAll();
    }

    public void setModal(boolean modal) {
        this.modal = modal;
    }

    public boolean isModal() {
        return this.modal;
    }
}

然后，我使用NetBeans GUI绘制JInternalFrame，但只是更改了类声明中的代码以扩展ModalinernalFrame而不是JInternalFrame：

public class myDialog extends modalInternalFrame { 
....

然后使用它从我的顶级“桌面”JFrame（包含jDesktopPane1）中实际显示它：

我的问题是：如果内部框架有JComboBox或PopupMenu，当PopupMenu的一部分超出内部框架的边界时，该部分不会处理鼠标事件（您无法滚动该部分）

---

有什么想法吗？

如何使用

作业窗格。showInternalMessageDialog（…）

：

• 我正在Windows 7 x64上运行JDK 1.7.021：

import java.awt.*；
导入java.awt.event.*；
导入javax.swing.*；
导入javax.swing.event.*；
公共类ModalInternalFrameTest{
私有最终JDesktopPane桌面=新JDesktopPane（）；
私有最终字符串[]项=新字符串[]{
“香蕉”、“比萨饼”、“热狗”、“馄饨”
};
私有最终操作openAction=新抽象操作（“打开”）{
@覆盖已执行的公共无效操作（ActionEvent e）{
JComboBox组合=新的JComboBox（项目）；
combo.setEditable（真）；
showInternalMessageDialog（桌面、组合）；
System.out.println（combo.getSelectedItem（））；
}
};
公共JComponentMakeUI（JFrame）{
setJMenuBar（createMenuBar（））；
JButton按钮=新JButton（openAction）；
按钮设置助记符（KeyEvent.VK_S）；
JInternalFrame内部=新的JInternalFrame（“按钮”）；
内部.getContentPane（）.add（按钮）；
内部.立根（20,20,100,100）；
桌面。添加（内部）；
内部设置可见（true）；
JButton b=新JButton（新抽象动作（“嘟嘟声”）{
@覆盖已执行的公共无效操作（ActionEvent e）{
getDefaultToolkit（）.beep（）；
}
});
b、 设置助记符（KeyEvent.VK_b）；
JPanel p=newjpanel（newborderlayout（））；
p、 增加（b，南部边界布局）；
p、 添加（桌面）；
返回p；
}
私有JMenuBar createMenuBar（）{
JMenuBar menuBar=新的JMenuBar（）；
JMenu菜单=新JMenu（“帧”）；
menu.set助记符（KeyEvent.VK_F）；
菜单栏。添加（菜单）；
JMenuItem menuItem=新的JMenuItem（openAction）；
menuItem.set助记符（KeyEvent.VK_1）；
menuItem.setAccelerator(
getKeyStroke（KeyEvent.VK_1，ActionEvent.ALT_MASK））；
menu.add（menuItem）；
返回菜单栏；
}
公共静态void main（字符串[]args）{
invokeLater（新的Runnable（）{
@重写公共无效运行（）{
createAndShowGUI（）；
}
});
}
公共静态void createAndShowGUI（）{
JFrame f=新的JFrame（）；
f、 setDefaultCloseOperation（WindowConstants.EXIT_ON_CLOSE）；
f、 getContentPane（）.add（新的ModalInternalFrameTest（）.makeUI（f））；
f、 设置大小（640480）；
f、 setLocationRelativeTo（空）；
f、 setVisible（真）；
}
}

如何使用

作业窗格。showInternalMessageDialog（…）

：

• 我正在Windows 7 x64上运行JDK 1.7.021：

import java.awt.*；
导入java.awt.event.*；
导入javax.swing.*；
导入javax.swing.event.*；
公共类ModalInternalFrameTest{
私有最终JDesktopPane桌面=新JDesktopPane（）；
私有最终字符串[]项=新字符串[]{
“香蕉”、“比萨饼”、“热狗”、“馄饨”
};
私有最终操作openAction=新抽象操作（“打开”）{
@覆盖已执行的公共无效操作（ActionEvent e）{
JComboBox组合=新的JComboBox（项目）；
combo.setEditable（真）；
showInternalMessageDialog（桌面、组合）；
System.out.println（combo.getSelectedItem（））；
}
};
公共JComponentMakeUI（JFrame）{
setJMenuBar（createMenuBar（））；
JButton按钮=新JButton（openAction）；
按钮设置助记符（KeyEvent.VK_S）；
JInternalFrame内部=新的JInternalFrame（“按钮”）；
内部.getContentPane（）.add（按钮）；
内部.立根（20,20,100,100）；
桌面。添加（内部）；
内部设置可见（true）；
JButton b=新JButton（新抽象动作（“嘟嘟声”）{
@覆盖已执行的公共无效操作（ActionEvent e）{
getDefaultToolkit（）.beep（）；
}
});
b、 设置助记符（KeyEvent.VK_b）；
JPanel p=newjpanel（newborderlayout（））；
p、 增加（b，南部边界布局）；
p、 添加（桌面）；
返回p；
}
私有JMenuBar createMenuBar（）{
JMenuBar menuBar=新的JMenuBar（）；
JMenu菜单=新JMenu（“帧”）；
menu.set助记符（KeyEvent.VK_F）；
菜单栏。添加（菜单）；
JMenuItem menuItem=新的JMenuItem（openAction）；
menuItem.set助记符（KeyEvent.VK_1）；
menuItem.setAccelerator(
getKeyStroke（KeyEvent.VK_1，ActionEvent.ALT_MASK））；
menu.add（menuItem）；
返回菜单栏；
}
公共静态void main（字符串[]args）{
invokeLater（新的Runnable（）{
@重写公共无效运行（）{
createAndShowGUI（）；
}
});
}
公共静态void createAndShowGUI（）{
JFrame f=新的JFrame（）；
f、 setDefaultCloseOperation（WindowConstants.EXIT_ON_CLOSE）；
f、 getContentPane（）.add（新的ModalInternalFrameTest（）.makeUI（f））；
f、 设置大小（640480）；
f、 setLocationRelativeTo（空）；
f、 setVisible（真）；
}
}

有三种类型的弹出窗口：

• 轻量
• 中等重量
• 重量级

唯一在模态状态下工作的是重量级弹出窗口。更改弹出窗口权重的“官方”方法是通过

setLightWeightPopupEnabled（布尔aFlag）

方法。 如果将其设置为false，则当弹出窗口位于应用程序框架内时，弹出窗口将为中等重量，当弹出窗口超出框架边界时，弹出窗口将为重型

要强制重量级，必须使用名为javax.swing.ClientPropertyKey.PopupFactory\u force\u heavweight\u POPUP的客户端属性。使用此属性，您可以强制弹出窗口（或容器中的每个弹出窗口）变重。但访问它的唯一方法是通过ref

myDialog d = new myDialog();
d.setModal(true);
d.setBounds(160, 180, 550, 450);
jDesktopPane1.add(d);
d.setVisible(true);

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;

public class ModalInternalFrameTest {
  private final JDesktopPane desktop = new JDesktopPane();
  private final String[] items = new String[] {
    "bananas", "pizza", "hot dogs", "ravioli"
  };
  private final Action openAction = new AbstractAction("open") {
    @Override public void actionPerformed(ActionEvent e) {
      JComboBox<String> combo = new JComboBox<String>(items);
      combo.setEditable(true);
      JOptionPane.showInternalMessageDialog(desktop, combo);
      System.out.println(combo.getSelectedItem());
    }
  };
  public JComponent makeUI(JFrame frame) {
    frame.setJMenuBar(createMenuBar());

    JButton button = new JButton(openAction);
    button.setMnemonic(KeyEvent.VK_S);
    JInternalFrame internal = new JInternalFrame("Button");
    internal.getContentPane().add(button);
    internal.setBounds(20, 20, 100, 100);
    desktop.add(internal);
    internal.setVisible(true);

    JButton b = new JButton(new AbstractAction("beep") {
      @Override public void actionPerformed(ActionEvent e) {
        Toolkit.getDefaultToolkit().beep();
      }
    });
    b.setMnemonic(KeyEvent.VK_B);

    JPanel p = new JPanel(new BorderLayout());
    p.add(b, BorderLayout.SOUTH);
    p.add(desktop);
    return p;
  }
  private JMenuBar createMenuBar() {
    JMenuBar menuBar = new JMenuBar();
    JMenu menu = new JMenu("Frame");
    menu.setMnemonic(KeyEvent.VK_F);
    menuBar.add(menu);

    JMenuItem menuItem = new JMenuItem(openAction);
    menuItem.setMnemonic(KeyEvent.VK_1);
    menuItem.setAccelerator(
      KeyStroke.getKeyStroke(KeyEvent.VK_1, ActionEvent.ALT_MASK));
    menu.add(menuItem);

    return menuBar;
  }
  public static void main(String[] args) {
    EventQueue.invokeLater(new Runnable() {
      @Override public void run() {
        createAndShowGUI();
      }
    });
  }
  public static void createAndShowGUI() {
    JFrame f = new JFrame();
    f.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
    f.getContentPane().add(new ModalInternalFrameTest().makeUI(f));
    f.setSize(640, 480);
    f.setLocationRelativeTo(null);
    f.setVisible(true);
  }
}

try {
  Class<?> enumElement = Class.forName("javax.swing.ClientPropertyKey");
  Object[] constants = enumElement.getEnumConstants();
  putClientProperty(constants[3], Boolean.TRUE);
}
catch(ClassNotFoundException ex) {}