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;
import java.beans.PropertyChangeListener;
+import java.beans.PropertyVetoException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
-import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
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;
private static boolean interactiveMode = true;
+ public static final Runnable NULLCALLABLE = () -> {
+ };
+
private Component parentComponent;
private ExecutorService executor = Executors.newCachedThreadPool();
private JDialog dialog = null;
- private Map<Object, Callable<Void>> callbacks = new HashMap<>();
+ private Map<Object, Runnable> callbacks = new HashMap<>();
+
+ private int timeout = -1;
+
+ public void setTimeout(int i)
+ {
+ timeout = i;
+ }
/*
* JalviewJS reports user choice in the dialog as the selected option (text);
private static void outputMessage(Object message)
{
- System.out.println(">>> JOption Message : " + message.toString());
+ jalview.bin.Console
+ .outPrintln(">>> JOption Message : " + message.toString());
}
public static Object getMockResponse()
"Supplied buttons array not the same length as supplied options array.");
break NOTNULL;
}
+
+ // run through buttons for initialValue first so we can set (and start)
+ // a final timeoutThreadF to include (and interrupt) in the button
+ // actions
+ Thread timeoutThread = null;
+ for (int i = 0; i < options.length; i++)
+ {
+ Object o = options[i];
+ JButton jb = buttons[i];
+ if (o.equals(initialValue))
+ {
+ if (timeout > 0 && jb != null && jb instanceof JButton)
+ {
+ // after timeout ms click the default button
+ timeoutThread = new Thread(() -> {
+ try
+ {
+ Thread.sleep(timeout);
+ } catch (InterruptedException e)
+ {
+ Console.debug(
+ "Dialog timeout interrupted. Probably a button pressed.");
+ }
+ jb.doClick();
+ });
+ }
+ initialValueButton = jb;
+ break;
+ }
+ }
+ final Thread timeoutThreadF = timeoutThread;
+ if (timeoutThreadF != null)
+ {
+ timeoutThreadF.start();
+ }
+
int[] buttonActions = { JOptionPane.YES_OPTION,
JOptionPane.NO_OPTION, JOptionPane.CANCEL_OPTION };
for (int i = 0; i < options.length; i++)
"Setting button " + i + " to '" + o.toString() + "'");
JButton jb = buttons[i];
- if (o.equals(initialValue))
- initialValueButton = jb;
-
int buttonAction = buttonActions[i];
- Callable<Void> action = callbacks.get(buttonAction);
+ Runnable action = callbacks.get(buttonAction);
jb.setText((String) o);
jb.addActionListener(new ActionListener()
{
@Override
public void actionPerformed(ActionEvent e)
{
+ if (timeoutThreadF != null)
+ {
+ timeoutThreadF.interrupt();
+ }
Object obj = e.getSource();
if (obj == null || !(obj instanceof Component))
JOptionPane joptionpane = (JOptionPane) joptionpaneObject;
joptionpane.setValue(buttonAction);
if (action != null)
- getExecutor().submit(action);
+ new Thread(action).start();
joptionpane.transferFocusBackward();
joptionpane.setVisible(false);
// put focus and raise parent window if possible, unless cancel or
{
Object o = options[i];
int buttonAction = buttonActions[i];
- Callable<Void> action = callbacks.get(buttonAction);
+ Runnable action = callbacks.get(buttonAction);
JButton jb = new JButton();
jb.setText((String) o);
jb.addActionListener(new ActionListener()
{
joptionpane.setValue(buttonAction);
if (action != null)
- getExecutor().submit(action);
+ new Thread(action).start();
// joptionpane.transferFocusBackward();
joptionpane.transferFocusBackward();
joptionpane.setVisible(false);
}
}
- public void showInternalDialog(JPanel mainPanel, String title,
+ public void showInternalDialog(Object mainPanel, String title,
int yesNoCancelOption, int questionMessage, Icon icon,
Object[] options, String initresponse)
{
this.setMessage(mainPanel);
ourOptions = Arrays.asList(options);
- int response;
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()
{
private void internalDialogHandleResponse()
{
- String responseString = (String) this.getValue();
+ Object value = this.getValue();
+ if (value == null
+ || (value instanceof Integer && (Integer) value == -1))
+ {
+ return;
+ }
+ String responseString = value.toString();
int response = ourOptions.indexOf(responseString);
if (!Platform.isJS())
* }
*/
@Override
- public JvOptionPane setResponseHandler(Object response,
- Callable<Void> action)
+ public JvOptionPane setResponseHandler(Object response, Runnable action)
{
+ if (action == null)
+ {
+ action = NULLCALLABLE;
+ }
callbacks.put(response, action);
return this;
}
- public ExecutorService getExecutor()
- {
- if (executor == null)
- executor = Executors.newSingleThreadExecutor();
- return executor;
- }
-
- public void setExecutor(ExecutorService es)
- {
- executor = es;
- }
-
public void setDialog(JDialog d)
{
dialog = d;
int JOPTIONPANE_MESSAGETYPE, Icon icon, Object[] options,
Object initialValue, boolean modal, JButton[] buttons)
{
+ showDialogOnTopAsync(dialogParent, label, actionString,
+ JOPTIONPANE_OPTION, JOPTIONPANE_MESSAGETYPE, icon, options,
+ initialValue, modal, buttons, true);
+ }
+
+ public void showDialogOnTopAsync(JFrame dialogParent, Object label,
+ String actionString, int JOPTIONPANE_OPTION,
+ int JOPTIONPANE_MESSAGETYPE, Icon icon, Object[] options,
+ Object initialValue, boolean modal, JButton[] buttons,
+ boolean dispose)
+ {
if (!isInteractiveMode())
{
handleResponse(getMockResponse());
// A better hack which works is to create a new JFrame parent with
// setAlwaysOnTop(true)
+ boolean parentOnTop = dialogParent.isAlwaysOnTop();
dialogParent.setAlwaysOnTop(true);
parentComponent = dialogParent;
JOPTIONPANE_MESSAGETYPE, icon, options, initialValue, modal,
buttons);
- dialogParent.setAlwaysOnTop(false);
- dialogParent.dispose();
+ dialogParent.setAlwaysOnTop(parentOnTop);
+
+ if (dispose)
+ {
+ dialogParent.setAlwaysOnTop(false);
+ dialogParent.dispose();
+ }
}
/**
{
return;
}
- Callable<Void> action = callbacks.get(response);
+ Runnable action = callbacks.get(response);
if (action != null)
{
try
{
- getExecutor().submit(action).get();
+ new Thread(action).start();
// action.call();
} catch (Exception e)
{
{
Object o = options[i];
int buttonAction = buttonActions[i];
- Callable<Void> action = callbacks.get(buttonAction);
+ Runnable action = callbacks.get(buttonAction);
JButton jb;
if (buttons != null && buttons.length > i && buttons[i] != null)
{
{
joptionpane.setValue(buttonAction);
if (action != null)
- getExecutor().submit(action);
+ new Thread(action).start();
// joptionpane.transferFocusBackward();
joptionpane.transferFocusBackward();
joptionpane.setVisible(false);
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
{
+ 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())
// EventQueue.dispatchEvent() directly, because it is
// protected, unfortunately.
if (ev instanceof ActiveEvent)
+ {
((ActiveEvent) ev).dispatch();
- else if (ev.getSource() instanceof Component)
+ }
+ 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)
+ {
((MenuComponent) ev.getSource()).dispatchEvent(ev);
+ }
+ else if (ev.getSource() instanceof Component)
+ {
+ ((Component) ev.getSource()).dispatchEvent(ev);
+ }
// Other events are ignored as per spec in
// EventQueue.dispatchEvent
}
// If we get interrupted, then leave the modal state.
} finally
{
+ // 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);
+ } catch (PropertyVetoException e)
+ {
+ f.doDefaultCloseAction();
+ }
+
// Remove the internal frame from its parent, so it is no longer
// lurking around and clogging memory.
Container parent = f.getParent();
if (parent != null)
+ {
parent.remove(f);
+ }
}
}
- public static JvOptionPane frameDialog(String message, String title,
+ public static JvOptionPane frameDialog(Object message, String title,
int messageType, String[] buttonsTextS, String defaultButtonS,
- Callable<Void>[] handlers, boolean modal)
+ List<Runnable> handlers, boolean modal)
{
JFrame parent = new JFrame();
JvOptionPane jvop = JvOptionPane.newOptionDialog();
{
dialogType = JOptionPane.YES_NO_CANCEL_OPTION;
}
- Callable<Void> nullCallable = () -> {
- return null;
- };
jvop.setResponseHandler(JOptionPane.YES_OPTION,
- (handlers != null && handlers.length > 0) ? handlers[0]
- : nullCallable);
+ (handlers != null && handlers.size() > 0) ? handlers.get(0)
+ : NULLCALLABLE);
if (dialogType == JOptionPane.YES_NO_OPTION
|| dialogType == JOptionPane.YES_NO_CANCEL_OPTION)
{
jvop.setResponseHandler(JOptionPane.NO_OPTION,
- (handlers != null && handlers.length > 1) ? handlers[1]
- : nullCallable);
+ (handlers != null && handlers.size() > 1) ? handlers.get(1)
+ : NULLCALLABLE);
}
if (dialogType == JOptionPane.YES_NO_CANCEL_OPTION)
{
jvop.setResponseHandler(JOptionPane.CANCEL_OPTION,
- (handlers != null && handlers.length > 2) ? handlers[2]
- : nullCallable);
+ (handlers != null && handlers.size() > 2) ? handlers.get(2)
+ : NULLCALLABLE);
}
final int dt = dialogType;
- jvop.getExecutor().execute(() -> {
+ new Thread(() -> {
jvop.showDialog(message, title, dt, messageType, null, buttonsText,
defaultButton, modal, buttons);
- });
+ }).start();
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);
+ }
+ }
+
}
git://source.jalview.org / jalview.git / blobdiff