* along with Jalview. If not, see <http://www.gnu.org/licenses/>.
* The Jalview Authors are detailed in the 'AUTHORS' file.
*/
-
package jalview.gui;
+import java.awt.AWTEvent;
+import java.awt.ActiveEvent;
import java.awt.Component;
+import java.awt.Container;
import java.awt.Dialog.ModalityType;
+import java.awt.EventQueue;
import java.awt.HeadlessException;
+import java.awt.MenuComponent;
+import java.awt.Toolkit;
import java.awt.Window;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
+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.Icon;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JInternalFrame;
+import javax.swing.JLayeredPane;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
+import javax.swing.SwingUtilities;
import javax.swing.UIManager;
+import javax.swing.event.InternalFrameEvent;
+import javax.swing.event.InternalFrameListener;
+import jalview.bin.Console;
+import jalview.util.ChannelProperties;
+import jalview.util.MessageManager;
import jalview.util.Platform;
import jalview.util.dialogrunner.DialogRunnerI;
{
private static final long serialVersionUID = -3019167117756785229L;
- private static Object mockResponse = JOptionPane.CANCEL_OPTION;
+ private static Object mockResponse = JvOptionPane.CANCEL_OPTION;
private static boolean interactiveMode = true;
+ public static final Runnable NULLCALLABLE = () -> {
+ };
+
private Component parentComponent;
- private Map<Object, Callable> callbacks = new HashMap<>();
+ private ExecutorService executor = Executors.newCachedThreadPool();
+
+ private JDialog dialog = null;
+
+ private Map<Object, Runnable> callbacks = new HashMap<>();
/*
- * JalviewJS reports user choice in the dialog as the selected
- * option (text); this list allows conversion to index (int)
+ * JalviewJS reports user choice in the dialog as the selected option (text);
+ * this list allows conversion to index (int)
*/
List<Object> ourOptions;
public JvOptionPane(final Component parent)
{
this.parentComponent = Platform.isJS() ? this : parent;
+ this.setIcon(null);
}
public static int showConfirmDialog(Component parentComponent,
}
switch (optionType)
{
- case JOptionPane.YES_NO_CANCEL_OPTION:
+ case JvOptionPane.YES_NO_CANCEL_OPTION:
// FeatureRenderer amendFeatures ?? TODO ??
// Chimera close
// PromptUserConfig
// $FALL-THROUGH$
default:
- case JOptionPane.YES_NO_OPTION:
+ case JvOptionPane.YES_NO_OPTION:
// PromptUserConfig usage stats
// for now treated as "OK CANCEL"
// $FALL-THROUGH$
- case JOptionPane.OK_CANCEL_OPTION:
+ case JvOptionPane.OK_CANCEL_OPTION:
// will fall back to simple HTML
return JOptionPane.showConfirmDialog(parentComponent, message, title,
optionType);
}
switch (optionType)
{
- case JOptionPane.YES_NO_CANCEL_OPTION:
+ case JvOptionPane.YES_NO_CANCEL_OPTION:
// ColourMenuHelper.addMenuItmers.offerRemoval TODO
- case JOptionPane.YES_NO_OPTION:
+ case JvOptionPane.YES_NO_OPTION:
// UserDefinedColoursSave -- relevant? TODO
// $FALL-THROUGH$
default:
- case JOptionPane.OK_CANCEL_OPTION:
+ case JvOptionPane.OK_CANCEL_OPTION:
// EditNameDialog --- uses panel for messsage TODO
}
switch (optionType)
{
- case JOptionPane.YES_NO_CANCEL_OPTION:
- case JOptionPane.YES_NO_OPTION:
+ case JvOptionPane.YES_NO_CANCEL_OPTION:
+ case JvOptionPane.YES_NO_OPTION:
// UserQuestionanaireCheck
// VamsasApplication
// $FALL-THROUGH$
default:
- case JOptionPane.OK_CANCEL_OPTION:
+ case JvOptionPane.OK_CANCEL_OPTION:
// will fall back to simple HTML
return JOptionPane.showConfirmDialog(parentComponent, message, title,
optionType, messageType);
}
switch (optionType)
{
- case JOptionPane.YES_NO_CANCEL_OPTION:
- case JOptionPane.YES_NO_OPTION:
+ case JvOptionPane.YES_NO_CANCEL_OPTION:
+ case JvOptionPane.YES_NO_OPTION:
//$FALL-THROUGH$
default:
- case JOptionPane.OK_CANCEL_OPTION:
+ case JvOptionPane.OK_CANCEL_OPTION:
// Preferences editLink/newLink
return JOptionPane.showConfirmDialog(parentComponent, message, title,
optionType, messageType, icon);
public static void resetMock()
{
- setMockResponse(JOptionPane.CANCEL_OPTION);
+ setMockResponse(JvOptionPane.CANCEL_OPTION);
setInteractiveMode(true);
}
{
switch (messageType)
{
- case JOptionPane.WARNING_MESSAGE:
+ case JvOptionPane.WARNING_MESSAGE:
prefix = "WARNING! ";
break;
- case JOptionPane.ERROR_MESSAGE:
+ case JvOptionPane.ERROR_MESSAGE:
prefix = "ERROR! ";
break;
default:
initialValue, true);
}
- public void showDialog(String message, String title, int optionType,
+ public void showDialog(Object message, String title, int optionType,
int messageType, Icon icon, Object[] options, Object initialValue,
boolean modal)
{
+ showDialog(message, title, optionType, messageType, icon, options,
+ initialValue, modal, null);
+ }
+
+ public void showDialog(Object message, String title, int optionType,
+ int messageType, Icon icon, Object[] options, Object initialValue,
+ boolean modal, JButton[] buttons)
+ {
if (!isInteractiveMode())
{
handleResponse(getMockResponse());
+ return;
}
// two uses:
//
if (modal)
{
+ boolean useButtons = false;
+ Object initialValueButton = null;
+ NOTNULL: if (buttons != null)
+ {
+ if (buttons.length != options.length)
+ {
+ jalview.bin.Console.error(
+ "Supplied buttons array not the same length as supplied options array.");
+ break NOTNULL;
+ }
+ int[] buttonActions = { JOptionPane.YES_OPTION,
+ JOptionPane.NO_OPTION, JOptionPane.CANCEL_OPTION };
+ for (int i = 0; i < options.length; i++)
+ {
+ Object o = options[i];
+ jalview.bin.Console.debug(
+ "Setting button " + i + " to '" + o.toString() + "'");
+ JButton jb = buttons[i];
+
+ if (o.equals(initialValue))
+ initialValueButton = jb;
+
+ int buttonAction = buttonActions[i];
+ Runnable action = callbacks.get(buttonAction);
+ jb.setText((String) o);
+ jb.addActionListener(new ActionListener()
+ {
+ @Override
+ public void actionPerformed(ActionEvent e)
+ {
+
+ Object obj = e.getSource();
+ if (obj == null || !(obj instanceof Component))
+ {
+ jalview.bin.Console.debug(
+ "Could not find Component source of event object "
+ + obj);
+ return;
+ }
+ Object joptionpaneObject = SwingUtilities.getAncestorOfClass(
+ JOptionPane.class, (Component) obj);
+ if (joptionpaneObject == null
+ || !(joptionpaneObject instanceof JOptionPane))
+ {
+ jalview.bin.Console.debug(
+ "Could not find JOptionPane ancestor of event object "
+ + obj);
+ return;
+ }
+ JOptionPane joptionpane = (JOptionPane) joptionpaneObject;
+ joptionpane.setValue(buttonAction);
+ if (action != null)
+ new Thread(action).start();
+ joptionpane.transferFocusBackward();
+ joptionpane.setVisible(false);
+ // put focus and raise parent window if possible, unless cancel or
+ // no button pressed
+ boolean raiseParent = (parentComponent != null);
+ if (buttonAction == JOptionPane.CANCEL_OPTION)
+ raiseParent = false;
+ if (optionType == JOptionPane.YES_NO_OPTION
+ && buttonAction == JOptionPane.NO_OPTION)
+ raiseParent = false;
+ if (raiseParent)
+ {
+ parentComponent.requestFocus();
+ if (parentComponent instanceof JInternalFrame)
+ {
+ JInternalFrame jif = (JInternalFrame) parentComponent;
+ jif.show();
+ jif.moveToFront();
+ jif.grabFocus();
+ }
+ else if (parentComponent instanceof Window)
+ {
+ Window w = (Window) parentComponent;
+ w.toFront();
+ w.requestFocus();
+ }
+ }
+ joptionpane.setVisible(false);
+ }
+ });
+
+ }
+ useButtons = true;
+ }
// use a JOptionPane as usual
int response = JOptionPane.showOptionDialog(parentComponent, message,
- title, optionType, messageType, icon, options, initialValue);
+ title, optionType, messageType, icon,
+ useButtons ? buttons : options,
+ useButtons ? initialValueButton : initialValue);
/*
- * In Java, the response is returned to this thread and handled here;
- * (for Javascript, see propertyChange)
+ * In Java, the response is returned to this thread and handled here; (for
+ * Javascript, see propertyChange)
*/
if (!Platform.isJS())
/**
else
{
/*
- * This is java similar to the swingjs handling, with the callbacks
- * attached to the button press of the dialog. This means we can use
- * a non-modal JDialog for the confirmation without blocking the GUI.
+ * This is java similar to the swingjs handling, with the callbacks attached to
+ * the button press of the dialog. This means we can use a non-modal JDialog for
+ * the confirmation without blocking the GUI.
*/
+ JOptionPane joptionpane = new JOptionPane();
+ // Make button options
+ int[] buttonActions = { JvOptionPane.YES_OPTION,
+ JvOptionPane.NO_OPTION, JvOptionPane.CANCEL_OPTION };
+
+ // we need the strings to make the buttons with actionEventListener
+ if (options == null)
+ {
+ ArrayList<String> options_default = new ArrayList<>();
+ options_default
+ .add(UIManager.getString("OptionPane.yesButtonText"));
+ if (optionType == JvOptionPane.YES_NO_OPTION
+ || optionType == JvOptionPane.YES_NO_CANCEL_OPTION)
+ {
+ options_default
+ .add(UIManager.getString("OptionPane.noButtonText"));
+ }
+ if (optionType == JvOptionPane.YES_NO_CANCEL_OPTION)
+ {
+ options_default
+ .add(UIManager.getString("OptionPane.cancelButtonText"));
+ }
+ options = options_default.toArray();
+ }
+
+ ArrayList<JButton> options_btns = new ArrayList<>();
+ Object initialValue_btn = null;
+ if (!Platform.isJS()) // JalviewJS already uses callback, don't need to
+ // add them here
+ {
+ for (int i = 0; i < options.length && i < 3; i++)
+ {
+ Object o = options[i];
+ int buttonAction = buttonActions[i];
+ Runnable action = callbacks.get(buttonAction);
+ JButton jb = new JButton();
+ jb.setText((String) o);
+ jb.addActionListener(new ActionListener()
+ {
- JDialog dialog = this.createDialog(parentComponent, message, title,
- optionType, messageType, icon, options, initialValue, modal);
- jalview.bin.Console.debug("About to setVisible(true)");
+ @Override
+ public void actionPerformed(ActionEvent e)
+ {
+ joptionpane.setValue(buttonAction);
+ if (action != null)
+ new Thread(action).start();
+ // joptionpane.transferFocusBackward();
+ joptionpane.transferFocusBackward();
+ joptionpane.setVisible(false);
+ // put focus and raise parent window if possible, unless cancel
+ // button pressed
+ boolean raiseParent = (parentComponent != null);
+ if (buttonAction == JvOptionPane.CANCEL_OPTION)
+ raiseParent = false;
+ if (optionType == JvOptionPane.YES_NO_OPTION
+ && buttonAction == JvOptionPane.NO_OPTION)
+ raiseParent = false;
+ if (raiseParent)
+ {
+ parentComponent.requestFocus();
+ if (parentComponent instanceof JInternalFrame)
+ {
+ JInternalFrame jif = (JInternalFrame) parentComponent;
+ jif.show();
+ jif.moveToFront();
+ jif.grabFocus();
+ }
+ else if (parentComponent instanceof Window)
+ {
+ Window w = (Window) parentComponent;
+ w.toFront();
+ w.requestFocus();
+ }
+ }
+ joptionpane.setVisible(false);
+ }
+ });
+ options_btns.add(jb);
+ if (o.equals(initialValue))
+ initialValue_btn = jb;
+ }
+ }
+ joptionpane.setMessage(message);
+ joptionpane.setMessageType(messageType);
+ joptionpane.setOptionType(optionType);
+ joptionpane.setIcon(icon);
+ joptionpane.setOptions(
+ Platform.isJS() ? options : options_btns.toArray());
+ joptionpane.setInitialValue(
+ Platform.isJS() ? initialValue : initialValue_btn);
+
+ JDialog dialog = joptionpane.createDialog(parentComponent, title);
+ dialog.setIconImages(ChannelProperties.getIconList());
+ dialog.setModalityType(modal ? ModalityType.APPLICATION_MODAL
+ : ModalityType.MODELESS);
+ dialog.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
dialog.setVisible(true);
- jalview.bin.Console.debug("Just setVisible(true)");
+ setDialog(dialog);
}
}
- public void showInternalDialog(JPanel mainPanel, String title,
+ public void showInternalDialog(Object mainPanel, String title,
int yesNoCancelOption, int questionMessage, Icon icon,
Object[] options, String initresponse)
{
handleResponse(getMockResponse());
}
+ // need to set these separately so we can set the title bar icon later
+ this.setOptionType(yesNoCancelOption);
+ this.setMessageType(questionMessage);
+ this.setIcon(icon);
+ this.setInitialValue(initresponse);
+ this.setOptions(options);
+ this.setMessage(mainPanel);
+
ourOptions = Arrays.asList(options);
- int response;
- if (parentComponent != this)
+ if (parentComponent != this
+ && !(parentComponent == null && Desktop.instance == null))
{
- response = JOptionPane.showInternalOptionDialog(parentComponent,
- mainPanel, title, yesNoCancelOption, questionMessage, icon,
- options, initresponse);
+ 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);
+ startModal(jif);
+ return;
}
else
{
- response = JOptionPane.showOptionDialog(parentComponent, mainPanel,
- title, yesNoCancelOption, questionMessage, icon, options,
- initresponse);
+ JDialog dialog = this.createDialog(parentComponent, title);
+ dialog.setIconImages(ChannelProperties.getIconList());
+ dialog.setVisible(true); // blocking
+ this.internalDialogHandleResponse();
+ return;
}
+ }
+
+ private void internalDialogHandleResponse()
+ {
+ String responseString = (String) this.getValue();
+ int response = ourOptions.indexOf(responseString);
+
if (!Platform.isJS())
/**
* Java only
}
/*
+ * @Override public JvOptionPane setResponseHandler(Object response, Runnable
+ * action) { callbacks.put(response, new Callable<Void>() {
+ *
+ * @Override public Void call() { action.run(); return null; } }); return this;
+ * }
+ */
@Override
public JvOptionPane setResponseHandler(Object response, Runnable action)
{
- callbacks.put(response, new Callable<Void>()
+ if (action == null)
{
- @Override
- public Void call()
- {
- action.run();
- return null;
- }
- });
+ action = NULLCALLABLE;
+ }
+ callbacks.put(response, action);
return this;
}
- */
- @Override
- public JvOptionPane setResponseHandler(Object response, Callable action)
+
+ public void setDialog(JDialog d)
{
- callbacks.put(response, action);
- return this;
+ dialog = d;
+ }
+
+ public JDialog getDialog()
+ {
+ return dialog;
}
/**
public static int showDialogOnTop(String label, String actionString,
int JOPTIONPANE_OPTION, int JOPTIONPANE_MESSAGETYPE)
{
+ return showDialogOnTop(null, label, actionString, JOPTIONPANE_OPTION,
+ JOPTIONPANE_MESSAGETYPE);
+ }
+
+ public static int showDialogOnTop(Component dialogParentComponent,
+ String label, String actionString, int JOPTIONPANE_OPTION,
+ int JOPTIONPANE_MESSAGETYPE)
+ {
+ if (!isInteractiveMode())
+ {
+ return (int) getMockResponse();
+ }
// Ensure Jalview window is brought to front (primarily for Quit
// confirmation window to be visible)
// A better hack which works is to create a new JFrame parent with
// setAlwaysOnTop(true)
JFrame dialogParent = new JFrame();
- dialogParent.setAlwaysOnTop(true);
+ if (dialogParentComponent == null)
+ {
+ dialogParent.setIconImages(ChannelProperties.getIconList());
+ dialogParent.setAlwaysOnTop(true);
+ }
- int answer = JOptionPane.showConfirmDialog(dialogParent, label,
- actionString, JOPTIONPANE_OPTION, JOPTIONPANE_MESSAGETYPE);
+ int answer = JOptionPane.showConfirmDialog(
+ dialogParentComponent == null ? dialogParent
+ : dialogParentComponent,
+ label, actionString, JOPTIONPANE_OPTION,
+ JOPTIONPANE_MESSAGETYPE);
- dialogParent.setAlwaysOnTop(false);
- jalview.bin.Console.debug("*********** BEFORE dialogParent.dispose()");
- dialogParent.dispose();
- jalview.bin.Console.debug("*********** BEFORE dialogParent.dispose()");
+ if (dialogParentComponent == null)
+ {
+ dialogParent.setAlwaysOnTop(false);
+ dialogParent.dispose();
+ }
return answer;
}
int JOPTIONPANE_OPTION, int JOPTIONPANE_MESSAGETYPE, Icon icon,
Object[] options, Object initialValue, boolean modal)
{
+ JFrame frame = new JFrame();
+ frame.setIconImages(ChannelProperties.getIconList());
+ showDialogOnTopAsync(frame, label, actionString, JOPTIONPANE_OPTION,
+ JOPTIONPANE_MESSAGETYPE, icon, options, initialValue, modal);
+ }
+
+ public void showDialogOnTopAsync(JFrame dialogParent, Object label,
+ String actionString, int JOPTIONPANE_OPTION,
+ int JOPTIONPANE_MESSAGETYPE, Icon icon, Object[] options,
+ Object initialValue, boolean modal)
+ {
+ showDialogOnTopAsync(dialogParent, label, actionString,
+ JOPTIONPANE_OPTION, JOPTIONPANE_MESSAGETYPE, icon, options,
+ initialValue, modal, null);
+ }
+
+ 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)
+ {
+ if (!isInteractiveMode())
+ {
+ handleResponse(getMockResponse());
+ return;
+ }
// Ensure Jalview window is brought to front (primarily for Quit
// confirmation window to be visible)
// A better hack which works is to create a new JFrame parent with
// setAlwaysOnTop(true)
- JFrame dialogParent = new JFrame();
dialogParent.setAlwaysOnTop(true);
parentComponent = dialogParent;
showDialog(label, actionString, JOPTIONPANE_OPTION,
- JOPTIONPANE_MESSAGETYPE, icon, options, initialValue, modal);
+ JOPTIONPANE_MESSAGETYPE, icon, options, initialValue, modal,
+ buttons);
dialogParent.setAlwaysOnTop(false);
dialogParent.dispose();
public void handleResponse(Object response)
{
/*
- * this test is for NaN in Chrome
- */
+ * this test is for NaN in Chrome
+ */
if (response != null && !response.equals(response))
{
return;
}
- Callable<Void> action = callbacks.get(response);
+ Runnable action = callbacks.get(response);
if (action != null)
{
try
{
- action.call();
+ new Thread(action).start();
+ // action.call();
} catch (Exception e)
{
e.printStackTrace();
/**
* Create a non-modal confirm dialog
*/
- public JDialog createDialog(Component parentComponent, String message,
+ public JDialog createDialog(Component parentComponent, Object message,
String title, int optionType, int messageType, Icon icon,
Object[] options, Object initialValue, boolean modal)
{
+ return createDialog(parentComponent, message, title, optionType,
+ messageType, icon, options, initialValue, modal, null);
+ }
+
+ public JDialog createDialog(Component parentComponent, Object message,
+ String title, int optionType, int messageType, Icon icon,
+ Object[] options, Object initialValue, boolean modal,
+ JButton[] buttons)
+ {
+ if (!isInteractiveMode())
+ {
+ handleResponse(getMockResponse());
+ return null;
+ }
+ JButton[] optionsButtons = null;
+ Object initialValueButton = null;
JOptionPane joptionpane = new JOptionPane();
// Make button options
int[] buttonActions = { JOptionPane.YES_OPTION, JOptionPane.NO_OPTION,
}
options = options_default.toArray();
}
- ArrayList<JButton> options_btns = new ArrayList<>();
- Object initialValue_btn = null;
if (!Platform.isJS()) // JalviewJS already uses callback, don't need to
// add them here
{
- if (((optionType == JOptionPane.YES_NO_OPTION
- || optionType == JOptionPane.OK_CANCEL_OPTION)
- && options.length < 2)
+ if (((optionType == JOptionPane.YES_OPTION
+ || optionType == JOptionPane.NO_OPTION
+ || optionType == JOptionPane.CANCEL_OPTION
+ || optionType == JOptionPane.OK_OPTION
+ || optionType == JOptionPane.DEFAULT_OPTION)
+ && options.length < 1)
+ || ((optionType == JOptionPane.YES_NO_OPTION
+ || optionType == JOptionPane.OK_CANCEL_OPTION)
+ && options.length < 2)
|| (optionType == JOptionPane.YES_NO_CANCEL_OPTION
&& options.length < 3))
{
jalview.bin.Console
.debug("JvOptionPane: not enough options for dialog type");
}
+ optionsButtons = new JButton[options.length];
for (int i = 0; i < options.length && i < 3; i++)
{
Object o = options[i];
int buttonAction = buttonActions[i];
- Callable action = callbacks.get(buttonAction);
- JButton jb = new JButton();
+ Runnable action = callbacks.get(buttonAction);
+ JButton jb;
+ if (buttons != null && buttons.length > i && buttons[i] != null)
+ {
+ jb = buttons[i];
+ }
+ else
+ {
+ jb = new JButton();
+ }
jb.setText((String) o);
jb.addActionListener(new ActionListener()
{
{
joptionpane.setValue(buttonAction);
if (action != null)
- Executors.newSingleThreadExecutor().submit(action);
+ new Thread(action).start();
// joptionpane.transferFocusBackward();
joptionpane.transferFocusBackward();
joptionpane.setVisible(false);
joptionpane.setVisible(false);
}
});
- options_btns.add(jb);
+ optionsButtons[i] = jb;
if (o.equals(initialValue))
- initialValue_btn = jb;
+ initialValueButton = jb;
}
}
joptionpane.setMessage(message);
joptionpane.setMessageType(messageType);
joptionpane.setOptionType(optionType);
joptionpane.setIcon(icon);
- joptionpane
- .setOptions(Platform.isJS() ? options : options_btns.toArray());
+ joptionpane.setOptions(Platform.isJS() ? options : optionsButtons);
joptionpane.setInitialValue(
- Platform.isJS() ? initialValue : initialValue_btn);
+ Platform.isJS() ? initialValue : initialValueButton);
JDialog dialog = joptionpane.createDialog(parentComponent, title);
+ dialog.setIconImages(ChannelProperties.getIconList());
dialog.setModalityType(
modal ? ModalityType.APPLICATION_MODAL : ModalityType.MODELESS);
dialog.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
+ setDialog(dialog);
return dialog;
}
return false;
}
+
+ /**
+ * This helper method makes the JInternalFrame wait until it is notified by an
+ * InternalFrameClosing event. This method also adds the given JOptionPane to
+ * the JInternalFrame and sizes it according to the JInternalFrame's preferred
+ * size.
+ *
+ * @param f
+ * The JInternalFrame to make modal.
+ */
+ private static void startModal(JInternalFrame f)
+ {
+ // We need to add an additional glasspane-like component directly
+ // below the frame, which intercepts all mouse events that are not
+ // directed at the frame itself.
+ JPanel modalInterceptor = new JPanel();
+ modalInterceptor.setOpaque(false);
+ JLayeredPane lp = JLayeredPane.getLayeredPaneAbove(f);
+ lp.setLayer(modalInterceptor, JLayeredPane.MODAL_LAYER.intValue());
+ modalInterceptor.setBounds(0, 0, lp.getWidth(), lp.getHeight());
+ modalInterceptor.addMouseListener(new MouseAdapter()
+ {
+ });
+ modalInterceptor.addMouseMotionListener(new MouseMotionAdapter()
+ {
+ });
+ lp.add(modalInterceptor);
+ f.toFront();
+
+ // 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 (EventQueue.isDispatchThread())
+ {
+ // The getNextEventMethod() issues wait() when no
+ // event is available, so we don't need do explicitly wait().
+ AWTEvent ev = queue.getNextEvent();
+ // 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 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(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++)
+ {
+ buttons[i] = new JButton();
+ buttons[i].setText(buttonsText[i]);
+ Console.debug("DISABLING BUTTON " + buttons[i].getText());
+ buttons[i].setEnabled(false);
+ buttons[i].setVisible(false);
+ }
+
+ int dialogType = -1;
+ if (buttonsText.length == 1)
+ {
+ dialogType = JOptionPane.OK_OPTION;
+ }
+ else if (buttonsText.length == 2)
+ {
+ dialogType = JOptionPane.YES_NO_OPTION;
+ }
+ else
+ {
+ dialogType = JOptionPane.YES_NO_CANCEL_OPTION;
+ }
+ 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 != null && handlers.size() > 1) ? handlers.get(1)
+ : NULLCALLABLE);
+ }
+ if (dialogType == JOptionPane.YES_NO_CANCEL_OPTION)
+ {
+ jvop.setResponseHandler(JOptionPane.CANCEL_OPTION,
+ (handlers != null && handlers.size() > 2) ? handlers.get(2)
+ : NULLCALLABLE);
+ }
+
+ final int dt = dialogType;
+ new Thread(() -> {
+ jvop.showDialog(message, title, dt, messageType, null, buttonsText,
+ defaultButton, modal, buttons);
+ }).start();
+
+ return jvop;
+ }
}
git://source.jalview.org / jalview.git / blobdiff