JAL-3851 remove old interface
[jalview.git] / src / jalview / gui / JvOptionPane.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
4  * 
5  * This file is part of Jalview.
6  * 
7  * Jalview is free software: you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License 
9  * as published by the Free Software Foundation, either version 3
10  * of the License, or (at your option) any later version.
11  *  
12  * Jalview is distributed in the hope that it will be useful, but 
13  * WITHOUT ANY WARRANTY; without even the implied warranty 
14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
15  * PURPOSE.  See the GNU General Public License for more details.
16  * 
17  * You should have received a copy of the GNU General Public License
18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
19  * The Jalview Authors are detailed in the 'AUTHORS' file.
20  */
21
22 package jalview.gui;
23
24 import jalview.util.Platform;
25 import jalview.util.dialogrunner.DialogRunnerI;
26
27 import java.awt.Component;
28 import java.awt.HeadlessException;
29 import java.beans.PropertyChangeEvent;
30 import java.beans.PropertyChangeListener;
31 import java.util.Arrays;
32 import java.util.HashMap;
33 import java.util.List;
34 import java.util.Map;
35
36 import javax.swing.Icon;
37 import javax.swing.JOptionPane;
38 import javax.swing.JPanel;
39
40 public class JvOptionPane extends JOptionPane implements DialogRunnerI,
41     PropertyChangeListener
42 {
43   private static final long serialVersionUID = -3019167117756785229L;
44
45   private static Object mockResponse = JvOptionPane.CANCEL_OPTION;
46
47   private static boolean interactiveMode = true;
48
49   private Component parentComponent;
50
51   private Map<Object, Runnable> callbacks = new HashMap<>();
52
53   /*
54    * JalviewJS reports user choice in the dialog as the selected
55    * option (text); this list allows conversion to index (int)
56    */
57   List<Object> ourOptions;
58   
59   public JvOptionPane(final Component parent)
60   {
61     this.parentComponent = Platform.isJS() ? this : parent;
62   }
63
64   public static int showConfirmDialog(Component parentComponent,
65           Object message) throws HeadlessException
66   {
67     // only called by test
68     return isInteractiveMode()
69             ? JOptionPane.showConfirmDialog(parentComponent, message)
70             : (int) getMockResponse();
71   }
72
73   /**
74    * Message, title, optionType
75    * 
76    * @param parentComponent
77    * @param message
78    * @param title
79    * @param optionType
80    * @return
81    * @throws HeadlessException
82    */
83   public static int showConfirmDialog(Component parentComponent,
84           Object message, String title, int optionType)
85           throws HeadlessException
86   {
87     if (!isInteractiveMode())
88     {
89       return (int) getMockResponse();
90     }
91     switch (optionType)
92     {
93     case JvOptionPane.YES_NO_CANCEL_OPTION:
94       // FeatureRenderer amendFeatures  ?? TODO ??
95       // Chimera close
96       // PromptUserConfig
97       // $FALL-THROUGH$
98     default:
99     case JvOptionPane.YES_NO_OPTION:
100       // PromptUserConfig usage stats
101       // for now treated as "OK CANCEL"
102       // $FALL-THROUGH$
103     case JvOptionPane.OK_CANCEL_OPTION:
104       // will fall back to simple HTML
105       return JOptionPane.showConfirmDialog(parentComponent, message, title,
106               optionType);
107     }
108   }
109
110   /**
111    * Adds a message type. Fallback is to just add it in the beginning.
112    * 
113    * @param parentComponent
114    * @param message
115    * @param title
116    * @param optionType
117    * @param messageType
118    * @return
119    * @throws HeadlessException
120    */
121   public static int showConfirmDialog(Component parentComponent,
122           Object message, String title, int optionType, int messageType)
123           throws HeadlessException
124   {
125     // JalviewServicesChanged
126     // PromptUserConfig raiseDialog
127     return isInteractiveMode()
128             ? JOptionPane.showConfirmDialog(parentComponent, message, title,
129                     optionType, messageType)
130             : (int) getMockResponse();
131   }
132
133   /**
134    * Adds an icon
135    * 
136    * @param parentComponent
137    * @param message
138    * @param title
139    * @param optionType
140    * @param messageType
141    * @param icon
142    * @return
143    * @throws HeadlessException
144    */
145   public static int showConfirmDialog(Component parentComponent,
146           Object message, String title, int optionType, int messageType,
147           Icon icon) throws HeadlessException
148   {
149     // JvOptionPaneTest only
150     return isInteractiveMode()
151             ? JOptionPane.showConfirmDialog(parentComponent, message, title,
152                     optionType, messageType, icon)
153             : (int) getMockResponse();
154   }
155
156   /**
157    * Internal version "OK"
158    * 
159    * @param parentComponent
160    * @param message
161    * @return
162    */
163   public static int showInternalConfirmDialog(Component parentComponent,
164           Object message)
165   {
166     // JvOptionPaneTest only;
167     return isInteractiveMode() ? JOptionPane.showInternalConfirmDialog(
168             parentComponent, message) : (int) getMockResponse();
169   }
170
171   /**
172    * Internal version -- changed to standard version for now
173    * 
174    * @param parentComponent
175    * @param message
176    * @param title
177    * @param optionType
178    * @return
179    */
180   public static int showInternalConfirmDialog(Component parentComponent,
181           String message, String title, int optionType)
182   {
183     if (!isInteractiveMode())
184     {
185       return (int) getMockResponse();
186     }
187     switch (optionType)
188     {
189     case JvOptionPane.YES_NO_CANCEL_OPTION:
190       // ColourMenuHelper.addMenuItmers.offerRemoval TODO
191     case JvOptionPane.YES_NO_OPTION:
192       // UserDefinedColoursSave -- relevant? TODO
193       // $FALL-THROUGH$
194     default:
195     case JvOptionPane.OK_CANCEL_OPTION:
196
197       // EditNameDialog --- uses panel for messsage TODO
198
199       // Desktop.inputURLMenuItem
200       // WsPreferenses
201       return JOptionPane.showConfirmDialog(parentComponent, message, title,
202               optionType);
203     }
204   }
205
206   /**
207    * 
208    * @param parentComponent
209    * @param message
210    * @param title
211    * @param optionType
212    * @param messageType
213    * @return
214    */
215   public static int showInternalConfirmDialog(Component parentComponent,
216           Object message, String title, int optionType, int messageType)
217   {
218     if (!isInteractiveMode())
219     {
220       return (int) getMockResponse();
221     }
222     switch (optionType)
223     {
224     case JvOptionPane.YES_NO_CANCEL_OPTION:
225     case JvOptionPane.YES_NO_OPTION:
226       // UserQuestionanaireCheck
227       // VamsasApplication
228       // $FALL-THROUGH$
229     default:
230     case JvOptionPane.OK_CANCEL_OPTION:
231       // will fall back to simple HTML
232       return JOptionPane.showConfirmDialog(parentComponent, message, title,
233               optionType, messageType);
234     }
235   }
236
237   /**
238    * adds icon; no longer internal
239    * 
240    * @param parentComponent
241    * @param message
242    * @param title
243    * @param optionType
244    * @param messageType
245    * @param icon
246    * @return
247    */
248   public static int showInternalConfirmDialog(Component parentComponent,
249           Object message, String title, int optionType, int messageType,
250           Icon icon)
251   {
252     if (!isInteractiveMode())
253     {
254       return (int) getMockResponse();
255     }
256     switch (optionType)
257     {
258     case JvOptionPane.YES_NO_CANCEL_OPTION:
259     case JvOptionPane.YES_NO_OPTION:
260       //$FALL-THROUGH$
261     default:
262     case JvOptionPane.OK_CANCEL_OPTION:
263       // Preferences editLink/newLink
264       return JOptionPane.showConfirmDialog(parentComponent, message, title,
265               optionType, messageType, icon);
266     }
267
268   }
269
270   /**
271    * custom options full-featured
272    * 
273    * @param parentComponent
274    * @param message
275    * @param title
276    * @param optionType
277    * @param messageType
278    * @param icon
279    * @param options
280    * @param initialValue
281    * @return
282    * @throws HeadlessException
283    */
284   public static int showOptionDialog(Component parentComponent,
285           String message, String title, int optionType, int messageType,
286           Icon icon, Object[] options, Object initialValue)
287           throws HeadlessException
288   {
289     if (!isInteractiveMode())
290     {
291       return (int) getMockResponse();
292     }
293     // two uses:
294     //
295     // TODO
296     //
297     // 1) AlignViewport for openLinkedAlignment
298     //
299     // Show a dialog with the option to open and link (cDNA <-> protein) as a
300     // new
301     // alignment, either as a standalone alignment or in a split frame. Returns
302     // true if the new alignment was opened, false if not, because the user
303     // declined the offer.
304     //
305     // 2) UserDefinedColors warning about saving over a name already defined
306     //
307     return JOptionPane.showOptionDialog(parentComponent, message, title,
308             optionType, messageType, icon, options, initialValue);
309   }
310
311   /**
312    * Just an OK message
313    * 
314    * @param message
315    * @throws HeadlessException
316    */
317   public static void showMessageDialog(Component parentComponent,
318           String message) throws HeadlessException
319   {
320     if (!isInteractiveMode())
321     {
322       outputMessage(message);
323       return;
324     }
325
326     // test class only
327
328     JOptionPane.showMessageDialog(parentComponent, message);
329   }
330
331   /**
332    * OK with message, title, and type
333    * 
334    * @param parentComponent
335    * @param message
336    * @param title
337    * @param messageType
338    * @throws HeadlessException
339    */
340   public static void showMessageDialog(Component parentComponent,
341           String message, String title, int messageType)
342           throws HeadlessException
343   {
344     // 30 implementations -- all just fine.
345
346     if (!isInteractiveMode())
347     {
348       outputMessage(message);
349       return;
350     }
351
352     JOptionPane.showMessageDialog(parentComponent,
353             getPrefix(messageType) + message, title, messageType);
354   }
355
356   /**
357    * adds title and icon
358    * 
359    * @param parentComponent
360    * @param message
361    * @param title
362    * @param messageType
363    * @param icon
364    * @throws HeadlessException
365    */
366   public static void showMessageDialog(Component parentComponent,
367           String message, String title, int messageType, Icon icon)
368           throws HeadlessException
369   {
370
371     // test only
372
373     if (!isInteractiveMode())
374     {
375       outputMessage(message);
376       return;
377     }
378
379     JOptionPane.showMessageDialog(parentComponent, message, title,
380             messageType, icon);
381   }
382
383   /**
384    * was internal
385    * 
386    */
387   public static void showInternalMessageDialog(Component parentComponent,
388           Object message)
389   {
390
391     // WsPreferences only
392
393     if (!isInteractiveMode())
394     {
395       outputMessage(message);
396       return;
397     }
398
399     JOptionPane.showMessageDialog(parentComponent, message);
400   }
401
402
403   /**
404    * Adds title and messageType
405    * 
406    * @param parentComponent
407    * @param message
408    * @param title
409    * @param messageType
410    */
411   public static void showInternalMessageDialog(Component parentComponent,
412           String message, String title, int messageType)
413   {
414
415     // 41 references
416
417     if (!isInteractiveMode())
418     {
419       outputMessage(message);
420       return;
421     }
422
423     JOptionPane.showMessageDialog(parentComponent,
424             getPrefix(messageType) + message, title, messageType);
425   }
426
427   /**
428    * 
429    * @param parentComponent
430    * @param message
431    * @param title
432    * @param messageType
433    * @param icon
434    */
435   public static void showInternalMessageDialog(Component parentComponent,
436           Object message, String title, int messageType, Icon icon)
437   {
438
439     // test only
440
441     if (!isInteractiveMode())
442     {
443       outputMessage(message);
444       return;
445     }
446
447     JOptionPane.showMessageDialog(parentComponent, message, title,
448             messageType, icon);
449   }
450
451   /**
452    * 
453    * @param message
454    * @return
455    * @throws HeadlessException
456    */
457   public static String showInputDialog(Object message)
458           throws HeadlessException
459   {
460     // test only
461
462     if (!isInteractiveMode())
463     {
464       return getMockResponse().toString();
465     }
466
467     return JOptionPane.showInputDialog(message);
468   }
469
470   /**
471    * adds inital selection value
472    * 
473    * @param message
474    * @param initialSelectionValue
475    * @return
476    */
477   public static String showInputDialog(String message,
478           String initialSelectionValue)
479   {
480     if (!isInteractiveMode())
481     {
482       return getMockResponse().toString();
483     }
484
485     // AnnotationPanel character option
486
487     return JOptionPane.showInputDialog(message, initialSelectionValue);
488   }
489
490   /**
491    * adds inital selection value
492    * 
493    * @param message
494    * @param initialSelectionValue
495    * @return
496    */
497   public static String showInputDialog(Object message,
498           Object initialSelectionValue)
499   {
500     if (!isInteractiveMode())
501     {
502       return getMockResponse().toString();
503     }
504
505     // AnnotationPanel character option
506
507     return JOptionPane.showInputDialog(message, initialSelectionValue);
508   }
509   /**
510    * centered on parent
511    * 
512    * @param parentComponent
513    * @param message
514    * @return
515    * @throws HeadlessException
516    */
517   public static String showInputDialog(Component parentComponent,
518           String message) throws HeadlessException
519   {
520     // test only
521
522     return isInteractiveMode()
523             ? JOptionPane.showInputDialog(parentComponent, message)
524             : getMockResponse().toString();
525   }
526
527   /**
528    * input with initial selection
529    * 
530    * @param parentComponent
531    * @param message
532    * @param initialSelectionValue
533    * @return
534    */
535   public static String showInputDialog(Component parentComponent,
536           String message, String initialSelectionValue)
537   {
538     
539     // AnnotationPanel
540     
541     return isInteractiveMode()
542             ? JOptionPane.showInputDialog(parentComponent, message,
543                     initialSelectionValue)
544             : getMockResponse().toString();
545   }
546   
547
548   /**
549    * input with initial selection
550    * 
551    * @param parentComponent
552    * @param message
553    * @param initialSelectionValue
554    * @return
555    */
556   public static String showInputDialog(Component parentComponent,
557           Object message, Object initialSelectionValue)
558   {
559     
560     // AnnotationPanel
561     
562     return isInteractiveMode()
563             ? JOptionPane.showInputDialog(parentComponent, message,
564                     initialSelectionValue)
565             : getMockResponse().toString();
566   }
567
568   /**
569    * 
570    * @param parentComponent
571    * @param message
572    * @param title
573    * @param messageType
574    * @return
575    * @throws HeadlessException
576    */
577   public static String showInputDialog(Component parentComponent,
578           String message, String title, int messageType)
579           throws HeadlessException
580   {
581
582     // test only
583
584     return isInteractiveMode() ? JOptionPane
585             .showInputDialog(parentComponent, message, title, messageType)
586             : getMockResponse().toString();
587   }
588
589   /**
590    * Customized input option 
591    * 
592    * @param parentComponent
593    * @param message
594    * @param title
595    * @param messageType
596    * @param icon
597    * @param selectionValues
598    * @param initialSelectionValue
599    * @return
600    * @throws HeadlessException
601    */
602   public static Object showInputDialog(Component parentComponent,
603           Object message, String title, int messageType, Icon icon,
604           Object[] selectionValues, Object initialSelectionValue)
605           throws HeadlessException
606   {
607     
608     // test only
609     
610     return isInteractiveMode()
611             ? JOptionPane.showInputDialog(parentComponent, message, title,
612                     messageType, icon, selectionValues,
613                     initialSelectionValue)
614             : getMockResponse().toString();
615   }
616
617   
618   
619   /**
620    * internal version
621    * 
622    * @param parentComponent
623    * @param message
624    * @return
625    */
626   public static String showInternalInputDialog(Component parentComponent,
627           String message)
628   {
629     // test only
630     
631     return isInteractiveMode()
632             ? JOptionPane.showInternalInputDialog(parentComponent, message)
633             : getMockResponse().toString();
634   }
635
636   
637   /**
638    * internal with title and messageType
639    * 
640    * @param parentComponent
641    * @param message
642    * @param title
643    * @param messageType
644    * @return
645    */
646   public static String showInternalInputDialog(Component parentComponent,
647           String message, String title, int messageType)
648   {
649     
650     // AlignFrame tabbedPane_mousePressed
651     
652     return isInteractiveMode()
653             ? JOptionPane.showInternalInputDialog(parentComponent,
654                     getPrefix(messageType) + message, title, messageType)
655             : getMockResponse().toString();
656   }
657
658   /**
659    * customized internal
660    * 
661    * @param parentComponent
662    * @param message
663    * @param title
664    * @param messageType
665    * @param icon
666    * @param selectionValues
667    * @param initialSelectionValue
668    * @return
669    */
670   public static Object showInternalInputDialog(Component parentComponent,
671           String message, String title, int messageType, Icon icon,
672           Object[] selectionValues, Object initialSelectionValue)
673   {
674     // test only
675     
676     return isInteractiveMode()
677             ? JOptionPane.showInternalInputDialog(parentComponent, message,
678                     title, messageType, icon, selectionValues,
679                     initialSelectionValue)
680             : getMockResponse().toString();
681   }
682
683   
684   ///////////// end of options ///////////////
685   
686   
687   private static void outputMessage(Object message)
688   {
689     System.out.println(">>> JOption Message : " + message.toString());
690   }
691
692   public static Object getMockResponse()
693   {
694     return mockResponse;
695   }
696
697   public static void setMockResponse(Object mockOption)
698   {
699     JvOptionPane.mockResponse = mockOption;
700   }
701
702   public static void resetMock()
703   {
704     setMockResponse(JvOptionPane.CANCEL_OPTION);
705     setInteractiveMode(true);
706   }
707
708   public static boolean isInteractiveMode()
709   {
710     return interactiveMode;
711   }
712
713   public static void setInteractiveMode(boolean interactive)
714   {
715     JvOptionPane.interactiveMode = interactive;
716   }
717
718   private static String getPrefix(int messageType)
719   {
720     String prefix = ""; 
721     
722     // JavaScript only
723     if (Platform.isJS())
724     {
725       switch (messageType)
726       {
727       case JvOptionPane.WARNING_MESSAGE:
728         prefix = "WARNING! ";
729         break;
730       case JvOptionPane.ERROR_MESSAGE:
731         prefix = "ERROR! ";
732         break;
733       default:
734         prefix = "Note: ";
735       }
736     }
737     return prefix;
738   }
739
740   /**
741    * create a new option dialog that can be used to register responses - along
742    * lines of showOptionDialog
743    * 
744    * @param desktop
745    * @param question
746    * @param string
747    * @param defaultOption
748    * @param plainMessage
749    * @param object
750    * @param options
751    * @param string2
752    * @return
753    */
754   public static JvOptionPane newOptionDialog(Component parentComponent)
755   {
756     return new JvOptionPane(parentComponent);
757   }
758
759   public void showDialog(
760           String message, String title, int optionType, int messageType,
761           Icon icon, Object[] options, Object initialValue)
762   {
763
764     if (!isInteractiveMode())
765     {
766       handleResponse(getMockResponse());
767     }
768     // two uses:
769     //
770     // TODO
771     //
772     // 1) AlignViewport for openLinkedAlignment
773     //
774     // Show a dialog with the option to open and link (cDNA <-> protein) as a
775     // new
776     // alignment, either as a standalone alignment or in a split frame. Returns
777     // true if the new alignment was opened, false if not, because the user
778     // declined the offer.
779     //
780     // 2) UserDefinedColors warning about saving over a name already defined
781     //
782     
783     ourOptions = Arrays.asList(options);
784     
785     int response = JOptionPane.showOptionDialog(parentComponent, message, title,
786             optionType, messageType, icon, options, initialValue);
787     
788     /*
789      * In Java, the response is returned to this thread and handled here;
790      * (for Javascript, see propertyChange)
791      */
792     if (!Platform.isJS())
793     /**
794      * Java only
795      * 
796      * @j2sIgnore
797      */
798     {
799       handleResponse(response);
800     }
801   }
802
803   public void showInternalDialog(JPanel mainPanel, String title,
804           int yesNoCancelOption, int questionMessage, Icon icon,
805           Object[] options, String initresponse)
806   {
807     if (!isInteractiveMode())
808     {
809       handleResponse(getMockResponse());
810     }
811     
812     ourOptions = Arrays.asList(options);
813     int response;
814     if (parentComponent != this) 
815     {
816       response = JOptionPane.showInternalOptionDialog(parentComponent, mainPanel,
817               title, yesNoCancelOption, questionMessage, icon, options,
818               initresponse);
819     }
820     else
821     {
822       response = JOptionPane.showOptionDialog(parentComponent, mainPanel, title,
823               yesNoCancelOption, questionMessage, icon, options,
824               initresponse);
825     }
826     if (!Platform.isJS())
827     /**
828      * Java only
829      * 
830      * @j2sIgnore
831      */
832     {
833       handleResponse(response);
834     }
835   }
836     
837   @Override
838   public JvOptionPane setResponseHandler(Object response, Runnable action)
839   {
840         callbacks.put(response,  action);
841     return this;
842   }
843
844   /**
845    * JalviewJS signals option selection by a property change event
846    * for the option e.g. "OK".  This methods responds to that by
847    * running the response action that corresponds to that option.
848    * 
849    * @param evt
850    */
851   @Override
852   public void propertyChange(PropertyChangeEvent evt)
853   {
854     Object newValue = evt.getNewValue();
855         int ourOption = ourOptions.indexOf(newValue);
856     if (ourOption >= 0)
857     {
858       handleResponse(ourOption);
859     }
860     else
861     {
862       // try our luck..
863       handleResponse(newValue);
864     }
865   }
866
867   @Override
868   public void handleResponse(Object response)
869   {
870     /*
871          * this test is for NaN in Chrome
872          */
873     if (response != null && !response.equals(response))
874     {
875       return;
876     }
877     Runnable action = callbacks.get(response);
878     if (action != null)
879     {
880       action.run();
881     }
882   }
883 }