Merge branch 'bug/JAL-4214_system_freeze_when_opening_file_using_gui_in_linux' into...

diff --git a/src/jalview/gui/AlignFrame.java b/src/jalview/gui/AlignFrame.java
index 25376af..d225c2e 100644 (file)
--- a/src/jalview/gui/AlignFrame.java
+++ b/src/jalview/gui/AlignFrame.java
@@ -1669,6 +1669,8 @@ public class AlignFrame extends GAlignFrame implements DropTargetListener,
       closeAllTabs = true;
     }
 
+    Desktop.closeModal(this);
+
     try
     {
       if (alignPanels != null)
@@ -1698,6 +1700,7 @@ public class AlignFrame extends GAlignFrame implements DropTargetListener,
           featureSettings.close();
           featureSettings = null;
         }
+
         /*
          * this will raise an INTERNAL_FRAME_CLOSED event and this method will
          * be called recursively, with the frame now in 'closed' state

diff --git a/src/jalview/gui/Desktop.java b/src/jalview/gui/Desktop.java
index 66055a4..035da25 100644 (file)
--- a/src/jalview/gui/Desktop.java
+++ b/src/jalview/gui/Desktop.java
@@ -51,6 +51,7 @@ import java.awt.event.WindowEvent;
 import java.awt.geom.AffineTransform;
 import java.beans.PropertyChangeEvent;
 import java.beans.PropertyChangeListener;
+import java.beans.PropertyVetoException;
 import java.io.File;
 import java.io.FileWriter;
 import java.io.IOException;
@@ -63,6 +64,7 @@ import java.util.Hashtable;
 import java.util.List;
 import java.util.ListIterator;
 import java.util.Locale;
+import java.util.Map;
 import java.util.Vector;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
@@ -3675,17 +3677,19 @@ public class Desktop extends jalview.jbgui.GDesktop
   }
 
   /**
-   * checks if any progress bars are being displayed in any of the windows managed by the desktop
+   * checks if any progress bars are being displayed in any of the windows
+   * managed by the desktop
+   * 
    * @return
    */
   public boolean operationsAreInProgress()
   {
     JInternalFrame[] frames = getAllFrames();
-    for (JInternalFrame frame:frames)
+    for (JInternalFrame frame : frames)
     {
       if (frame instanceof IProgressIndicator)
       {
-        if (((IProgressIndicator)frame).operationInProgress())
+        if (((IProgressIndicator) frame).operationInProgress())
         {
           return true;
         }
@@ -3693,4 +3697,37 @@ public class Desktop extends jalview.jbgui.GDesktop
     }
     return operationInProgress();
   }
+
+  /**
+   * keep track of modal JvOptionPanes open as modal dialogs for AlignFrames.
+   * The way the modal JInternalFrame is made means it cannot be a child of an
+   * AlignFrame, so closing the AlignFrame might leave the modal open :(
+   */
+  private static Map<AlignFrame, JInternalFrame> alignFrameModalMap = new HashMap<>();
+
+  protected static void addModal(AlignFrame af, JInternalFrame jif)
+  {
+    alignFrameModalMap.put(af, jif);
+  }
+
+  protected static void closeModal(AlignFrame af)
+  {
+    if (!alignFrameModalMap.containsKey(af))
+    {
+      return;
+    }
+    JInternalFrame jif = alignFrameModalMap.get(af);
+    if (jif != null)
+    {
+      try
+      {
+        jif.setClosed(true);
+      } catch (PropertyVetoException e)
+      {
+        e.printStackTrace();
+      }
+    }
+    alignFrameModalMap.remove(af);
+  }
+
 }

diff --git a/src/jalview/gui/JvOptionPane.java b/src/jalview/gui/JvOptionPane.java
index eaaa2a1..5b926c3 100644 (file)
--- a/src/jalview/gui/JvOptionPane.java
+++ b/src/jalview/gui/JvOptionPane.java
@@ -32,6 +32,7 @@ import java.awt.Toolkit;
 import java.awt.Window;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
+import java.awt.event.KeyEvent;
 import java.awt.event.MouseAdapter;
 import java.awt.event.MouseMotionAdapter;
 import java.beans.PropertyChangeEvent;
@@ -51,8 +52,11 @@ import javax.swing.JDialog;
 import javax.swing.JFrame;
 import javax.swing.JInternalFrame;
 import javax.swing.JLayeredPane;
+import javax.swing.JMenu;
+import javax.swing.JMenuBar;
 import javax.swing.JOptionPane;
 import javax.swing.JPanel;
+import javax.swing.JRootPane;
 import javax.swing.SwingUtilities;
 import javax.swing.UIManager;
 import javax.swing.event.InternalFrameEvent;
@@ -1072,53 +1076,53 @@ public class JvOptionPane extends JOptionPane
     if (parentComponent != this
             && !(parentComponent == null && Desktop.instance == null))
     {
+      // note the parent goes back to a JRootPane so is probably
+      // Desktop.getDesktop()
       JInternalFrame jif = this.createInternalFrame(
               parentComponent != null ? parentComponent : Desktop.instance,
               title);
+      // connect to the alignFrame using a map in Desktop
+      if (parentComponent instanceof AlignFrame)
+      {
+        Desktop.addModal((AlignFrame) parentComponent, jif);
+      }
       jif.setFrameIcon(null);
       jif.addInternalFrameListener(new InternalFrameListener()
       {
         @Override
         public void internalFrameActivated(InternalFrameEvent arg0)
         {
-          System.err.println("##### internalFrameActivated");
         }
 
         @Override
         public void internalFrameClosed(InternalFrameEvent arg0)
         {
-          System.err.println("##### internalFrameClosed");
           JvOptionPane.this.internalDialogHandleResponse();
         }
 
         @Override
         public void internalFrameClosing(InternalFrameEvent arg0)
         {
-          System.err.println("##### internalFrameClosing");
         }
 
         @Override
         public void internalFrameDeactivated(InternalFrameEvent arg0)
         {
-          System.err.println("##### internalFrameDeactivated");
         }
 
         @Override
         public void internalFrameDeiconified(InternalFrameEvent arg0)
         {
-          System.err.println("##### internalFrameDeiconified");
         }
 
         @Override
         public void internalFrameIconified(InternalFrameEvent arg0)
         {
-          System.err.println("##### internalFrameIconified");
         }
 
         @Override
         public void internalFrameOpened(InternalFrameEvent arg0)
         {
-          System.err.println("##### internalFrameOpened");
         }
       });
       jif.setVisible(true);
@@ -1513,13 +1517,27 @@ public class JvOptionPane extends JOptionPane
     lp.add(modalInterceptor);
     f.toFront();
 
+    // disable the main menu bar if in Linux
+    JMenuBar menubar = null;
+    if (Platform.isLinux())
+    {
+      JRootPane rootpane = Desktop.getDesktop().getRootPane();
+      menubar = rootpane.getJMenuBar();
+    }
+
     // We need to explicitly dispatch events when we are blocking the event
     // dispatch thread.
     EventQueue queue = Toolkit.getDefaultToolkit().getSystemEventQueue();
     try
     {
-      boolean stillModal = true;
-      while (!f.isClosed() && stillModal)
+      if (menubar != null)
+      {
+        // don't allow clicks on main menu on linux due to a hanging bug.
+        // see JAL-4214.
+        setMenusEnabled(menubar, false);
+      }
+
+      while (!f.isClosed())
       {
         if (EventQueue.isDispatchThread())
         {
@@ -1529,53 +1547,53 @@ public class JvOptionPane extends JOptionPane
           // This mimics EventQueue.dispatchEvent(). We can't use
           // EventQueue.dispatchEvent() directly, because it is
           // protected, unfortunately.
-          System.out.println(
-                  "##### ev source=" + ev.getSource().getClass() + "");
           if (ev instanceof ActiveEvent)
           {
-            System.err.println("##### 1");
             ((ActiveEvent) ev).dispatch();
           }
+          else if (ev instanceof KeyEvent && ((KeyEvent) ev).isControlDown()
+                  && menubar != null)
+          {
+            // temporarily enable menus to send Ctrl+? KeyEvents
+            setMenusEnabled(menubar, true);
+            ((Component) ev.getSource()).dispatchEvent(ev);
+            setMenusEnabled(menubar, false);
+          }
           else if (ev.getSource() instanceof MenuComponent)
           {
-            System.err.println("##### 2");
             ((MenuComponent) ev.getSource()).dispatchEvent(ev);
           }
           else if (ev.getSource() instanceof Component)
           {
-            System.err.println("##### 3");
-            if (ev.getSource().equals(Desktop.getDesktop().getRootPane()))
-            {
-              stillModal = false;
-            }
-            else
-            {
-              ((Component) ev.getSource()).dispatchEvent(ev);
-            }
+            ((Component) ev.getSource()).dispatchEvent(ev);
           }
           // Other events are ignored as per spec in
           // EventQueue.dispatchEvent
-          System.err.println("##### 4");
         }
         else
         {
           // Give other threads a chance to become active.
-          System.err.println("##### 5");
           Thread.yield();
         }
       }
     } catch (InterruptedException ex)
     {
       // If we get interrupted, then leave the modal state.
-      System.err.println("##### 6");
     } finally
     {
-      System.err.println("##### 7");
+      // re-enable the main menu bar
+      if (menubar != null)
+      {
+        setMenusEnabled(menubar, true);
+      }
+
       // Clean up the modal interceptor.
       lp.remove(modalInterceptor);
 
+      // unpaint the frame
       f.setVisible(false);
 
+      // close the frame
       try
       {
         f.setClosed(true);
@@ -1661,4 +1679,14 @@ public class JvOptionPane extends JOptionPane
 
     return jvop;
   }
+
+  private static void setMenusEnabled(JMenuBar menubar, boolean b)
+  {
+    for (int i = 0; i < menubar.getMenuCount(); i++)
+    {
+      JMenu menu = menubar.getMenu(i);
+      menu.setEnabled(b);
+    }
+  }
+
 }