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 jalview.bin.Console;
import jalview.util.ChannelProperties;
+import jalview.util.MessageManager;
import jalview.util.Platform;
import jalview.util.dialogrunner.DialogRunnerI;
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<>();
/*
* JalviewJS reports user choice in the dialog as the selected option (text);
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()
{
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)
+ if (parentComponent != this
+ && !(parentComponent == null && Desktop.instance == null))
{
- JInternalFrame jif = this.createInternalFrame(parentComponent, title);
+ JInternalFrame jif = this.createInternalFrame(
+ parentComponent != null ? parentComponent : Desktop.instance,
+ title);
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);
* }
*/
@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;
{
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);
EventQueue queue = Toolkit.getDefaultToolkit().getSystemEventQueue();
try
{
- while (!f.isClosed())
+ boolean stillModal = true;
+ while (!f.isClosed() && stillModal)
{
if (EventQueue.isDispatchThread())
{
// 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.getSource() instanceof Component)
- ((Component) ev.getSource()).dispatchEvent(ev);
+ }
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);
+ }
+ }
// 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");
// Clean up the modal interceptor.
lp.remove(modalInterceptor);
+ f.setVisible(false);
+
+ 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,
- int messageType, String[] buttonsText, String defaultButton,
- Callable<Void>[] handlers, boolean modal)
+ public static JvOptionPane frameDialog(Object message, String title,
+ int messageType, String[] buttonsTextS, String defaultButtonS,
+ List<Runnable> handlers, boolean modal)
{
JFrame parent = new JFrame();
JvOptionPane jvop = JvOptionPane.newOptionDialog();
+ final String[] buttonsText;
+ final String defaultButton;
+ if (buttonsTextS == null)
+ {
+ String ok = MessageManager.getString("action.ok");
+ buttonsText = new String[] { ok };
+ defaultButton = ok;
+ }
+ else
+ {
+ buttonsText = buttonsTextS;
+ defaultButton = defaultButtonS;
+ }
JButton[] buttons = new JButton[buttonsText.length];
for (int i = 0; i < buttonsText.length; i++)
{
{
dialogType = JOptionPane.YES_NO_CANCEL_OPTION;
}
- jvop.setResponseHandler(JOptionPane.YES_OPTION, handlers[0]);
+ jvop.setResponseHandler(JOptionPane.YES_OPTION,
+ (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[1]);
+ jvop.setResponseHandler(JOptionPane.NO_OPTION,
+ (handlers != null && handlers.size() > 1) ? handlers.get(1)
+ : NULLCALLABLE);
}
if (dialogType == JOptionPane.YES_NO_CANCEL_OPTION)
{
- jvop.setResponseHandler(JOptionPane.CANCEL_OPTION, handlers[2]);
+ jvop.setResponseHandler(JOptionPane.CANCEL_OPTION,
+ (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;
}