Merge branch 'patch/JAL-4345_pae_epas1_doubleclick' into develop
[jalview.git] / src / jalview / gui / QuitHandler.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 package jalview.gui;
22
23 import java.io.File;
24 import java.util.List;
25 import java.util.Locale;
26 import java.util.concurrent.CompletableFuture;
27 import java.util.concurrent.ExecutionException;
28 import java.util.concurrent.ExecutorService;
29 import java.util.concurrent.Executors;
30 import java.util.concurrent.RejectedExecutionException;
31 import java.util.concurrent.TimeUnit;
32 import java.util.concurrent.TimeoutException;
33
34 import javax.swing.JButton;
35 import javax.swing.JFrame;
36 import javax.swing.JOptionPane;
37 import javax.swing.JTextPane;
38
39 import com.formdev.flatlaf.extras.FlatDesktop;
40 import com.formdev.flatlaf.extras.FlatDesktop.QuitResponse;
41
42 import jalview.api.AlignmentViewPanel;
43 import jalview.bin.Cache;
44 import jalview.bin.Console;
45 import jalview.datamodel.AlignmentI;
46 import jalview.datamodel.SequenceI;
47 import jalview.io.BackupFiles;
48 import jalview.project.Jalview2XML;
49 import jalview.util.MessageManager;
50 import jalview.util.Platform;
51
52 public class QuitHandler
53 {
54   private static final int MIN_WAIT_FOR_SAVE = 1000;
55
56   private static final int MAX_WAIT_FOR_SAVE = 20000;
57
58   private static boolean interactive = true;
59
60   private static QuitResponse flatlafResponse = null;
61
62   public static enum QResponse
63   {
64     NULL, QUIT, CANCEL_QUIT, FORCE_QUIT
65   };
66
67   public static enum Message
68   {
69     UNSAVED_CHANGES, UNSAVED_ALIGNMENTS
70   };
71
72   protected static Message message = Message.UNSAVED_CHANGES;
73
74   public static void setMessage(Message m)
75   {
76     message = m;
77   }
78
79   private static ExecutorService executor = Executors.newFixedThreadPool(3);
80
81   public static void setQuitHandler()
82   {
83     FlatDesktop.setQuitHandler(response -> {
84       flatlafResponse = response;
85       Desktop.instance.desktopQuit();
86     });
87   }
88
89   public static void startForceQuit()
90   {
91     setResponse(QResponse.FORCE_QUIT);
92   }
93
94   private static QResponse gotQuitResponse = QResponse.NULL;
95
96   protected static QResponse setResponse(QResponse qresponse)
97   {
98     gotQuitResponse = qresponse;
99     if ((qresponse == QResponse.CANCEL_QUIT || qresponse == QResponse.NULL)
100             && flatlafResponse != null)
101     {
102       flatlafResponse.cancelQuit();
103     }
104     return qresponse;
105   }
106
107   public static QResponse gotQuitResponse()
108   {
109     return gotQuitResponse;
110   }
111
112   public static final Runnable defaultCancelQuit = () -> {
113     Console.debug("QuitHandler: (default) Quit action CANCELLED by user");
114     // reset
115     setResponse(QResponse.CANCEL_QUIT);
116   };
117
118   public static final Runnable defaultOkQuit = () -> {
119     Console.debug("QuitHandler: (default) Quit action CONFIRMED by user");
120     setResponse(QResponse.QUIT);
121   };
122
123   public static final Runnable defaultForceQuit = () -> {
124     Console.debug("QuitHandler: (default) Quit action FORCED by user");
125     // note that shutdown hook will not be run
126     Runtime.getRuntime().halt(0);
127     setResponse(QResponse.FORCE_QUIT); // this line never reached!
128   };
129
130   public static QResponse getQuitResponse(boolean ui)
131   {
132     return getQuitResponse(ui, defaultOkQuit, defaultForceQuit,
133             defaultCancelQuit);
134   }
135
136   public static QResponse getQuitResponse(boolean ui, Runnable okQuit,
137           Runnable forceQuit, Runnable cancelQuit)
138   {
139     QResponse got = gotQuitResponse();
140     if (got != QResponse.NULL && got != QResponse.CANCEL_QUIT)
141     {
142       // quit has already been selected, continue with calling quit method
143       return got;
144     }
145
146     interactive = ui && !Platform.isHeadless();
147     // confirm quit if needed and wanted
148     boolean confirmQuit = true;
149
150     if (!interactive)
151     {
152       Console.debug("Non interactive quit -- not confirming");
153       confirmQuit = false;
154     }
155     else if (Jalview2XML.allSavedUpToDate())
156     {
157       Console.debug("Nothing changed -- not confirming quit");
158       confirmQuit = false;
159     }
160     else
161     {
162       confirmQuit = jalview.bin.Cache
163               .getDefault(jalview.gui.Desktop.CONFIRM_KEYBOARD_QUIT, true);
164       Console.debug("Jalview property '"
165               + jalview.gui.Desktop.CONFIRM_KEYBOARD_QUIT
166               + "' is/defaults to " + confirmQuit + " -- "
167               + (confirmQuit ? "" : "not ") + "confirming quit");
168     }
169     got = confirmQuit ? QResponse.NULL : QResponse.QUIT;
170     setResponse(got);
171
172     if (confirmQuit)
173     {
174       String messageString = MessageManager
175               .getString(message == Message.UNSAVED_ALIGNMENTS
176                       ? "label.unsaved_alignments"
177                       : "label.unsaved_changes");
178       setQuitDialog(JvOptionPane.newOptionDialog()
179               .setResponseHandler(JOptionPane.YES_OPTION, defaultOkQuit)
180               .setResponseHandler(JOptionPane.NO_OPTION, cancelQuit));
181       JvOptionPane qd = getQuitDialog();
182       qd.showDialogOnTopAsync(
183               new StringBuilder(
184                       MessageManager.getString("label.quit_jalview"))
185                               .append("\n").append(messageString)
186                               .toString(),
187               MessageManager.getString("action.quit"),
188               JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null,
189               new Object[]
190               { MessageManager.getString("action.quit"),
191                   MessageManager.getString("action.cancel") },
192               MessageManager.getString("action.quit"), true);
193     }
194
195     got = gotQuitResponse();
196
197     // check for external viewer frames
198     if (got != QResponse.CANCEL_QUIT)
199     {
200       int count = Desktop.instance.structureViewersStillRunningCount();
201       if (count > 0)
202       {
203         String alwaysCloseExternalViewers = Cache
204                 .getDefault("ALWAYS_CLOSE_EXTERNAL_VIEWERS", "ask");
205         String prompt = MessageManager
206                 .formatMessage(count == 1 ? "label.confirm_quit_viewer"
207                         : "label.confirm_quit_viewers");
208         String title = MessageManager.getString(
209                 count == 1 ? "label.close_viewer" : "label.close_viewers");
210         String cancelQuitText = MessageManager
211                 .getString("action.cancel_quit");
212         String[] buttonsText = { MessageManager.getString("action.yes"),
213             MessageManager.getString("action.no"), cancelQuitText };
214
215         int confirmResponse = -1;
216         if (alwaysCloseExternalViewers == null || "ask".equals(
217                 alwaysCloseExternalViewers.toLowerCase(Locale.ROOT)))
218         {
219           confirmResponse = JvOptionPane.showOptionDialog(Desktop.instance,
220                   prompt, title, JvOptionPane.YES_NO_CANCEL_OPTION,
221                   JvOptionPane.WARNING_MESSAGE, null, buttonsText,
222                   cancelQuit);
223         }
224         else
225         {
226           confirmResponse = Cache
227                   .getDefault("ALWAYS_CLOSE_EXTERNAL_VIEWERS", false)
228                           ? JvOptionPane.YES_OPTION
229                           : JvOptionPane.NO_OPTION;
230         }
231
232         if (confirmResponse == JvOptionPane.CANCEL_OPTION)
233         {
234           // Cancel Quit
235           QuitHandler.setResponse(QResponse.CANCEL_QUIT);
236         }
237         else
238         {
239           // Close viewers/Leave viewers open
240           StructureViewerBase
241                   .setQuitClose(confirmResponse == JvOptionPane.YES_OPTION);
242         }
243       }
244
245     }
246
247     got = gotQuitResponse();
248
249     boolean wait = false;
250     if (got == QResponse.CANCEL_QUIT)
251     {
252       // reset
253       Console.debug("Cancelling quit.  Resetting response to NULL");
254       setResponse(QResponse.NULL);
255       // but return cancel
256       return QResponse.CANCEL_QUIT;
257     }
258     else if (got == QResponse.QUIT)
259     {
260       if (Cache.getDefault("WAIT_FOR_SAVE", true)
261               && BackupFiles.hasSavesInProgress())
262       {
263         waitQuit(interactive, okQuit, forceQuit, cancelQuit);
264         QResponse waitResponse = gotQuitResponse();
265         wait = waitResponse == QResponse.QUIT;
266       }
267     }
268
269     Runnable next = null;
270     switch (gotQuitResponse())
271     {
272     case QUIT:
273       next = okQuit;
274       break;
275     case FORCE_QUIT: // not actually an option at this stage
276       next = forceQuit;
277       break;
278     default:
279       next = cancelQuit;
280       break;
281     }
282     try
283     {
284       executor.submit(next).get();
285       got = gotQuitResponse();
286     } catch (RejectedExecutionException e)
287     {
288       // QuitHander.abortQuit() probably called
289       // CANCEL_QUIT test will reset QuitHandler
290       Console.info("Quit aborted!");
291       got = QResponse.NULL;
292       setResponse(QResponse.NULL);
293     } catch (InterruptedException | ExecutionException e)
294     {
295       jalview.bin.Console
296               .debug("Exception during quit handling (final choice)", e);
297     }
298     setResponse(got);
299
300     if (quitCancelled())
301     {
302       // reset if cancelled
303       Console.debug("Quit cancelled");
304       setResponse(QResponse.NULL);
305       return QResponse.CANCEL_QUIT;
306     }
307     return gotQuitResponse();
308   }
309
310   private static QResponse waitQuit(boolean interactive, Runnable okQuit,
311           Runnable forceQuit, Runnable cancelQuit)
312   {
313     // check for saves in progress
314     if (!BackupFiles.hasSavesInProgress())
315       return QResponse.QUIT;
316
317     int size = 0;
318     AlignFrame[] afArray = Desktop.getDesktopAlignFrames();
319     if (!(afArray == null || afArray.length == 0))
320     {
321       for (int i = 0; i < afArray.length; i++)
322       {
323         AlignFrame af = afArray[i];
324         List<? extends AlignmentViewPanel> avpList = af.getAlignPanels();
325         for (AlignmentViewPanel avp : avpList)
326         {
327           AlignmentI a = avp.getAlignment();
328           List<SequenceI> sList = a.getSequences();
329           for (SequenceI s : sList)
330           {
331             size += s.getLength();
332           }
333         }
334       }
335     }
336     int waitTime = Math.min(MAX_WAIT_FOR_SAVE,
337             Math.max(MIN_WAIT_FOR_SAVE, size / 2));
338     Console.debug("Set waitForSave to " + waitTime);
339
340     int iteration = 0;
341     boolean doIterations = true; // note iterations not used in the gui now,
342                                  // only one pass without the "Wait" button
343     while (doIterations && BackupFiles.hasSavesInProgress()
344             && iteration++ < (interactive ? 100 : 5))
345     {
346       // future that returns a Boolean when all files are saved
347       CompletableFuture<Boolean> filesAllSaved = new CompletableFuture<>();
348
349       // callback as each file finishes saving
350       for (CompletableFuture<Boolean> cf : BackupFiles
351               .savesInProgressCompletableFutures(false))
352       {
353         // if this is the last one then complete filesAllSaved
354         cf.whenComplete((ret, e) -> {
355           if (!BackupFiles.hasSavesInProgress())
356           {
357             filesAllSaved.complete(true);
358           }
359         });
360       }
361       try
362       {
363         filesAllSaved.get(waitTime, TimeUnit.MILLISECONDS);
364       } catch (InterruptedException | ExecutionException e1)
365       {
366         Console.debug(
367                 "Exception whilst waiting for files to save before quit",
368                 e1);
369       } catch (TimeoutException e2)
370       {
371         // this Exception to be expected
372       }
373
374       if (interactive && BackupFiles.hasSavesInProgress())
375       {
376         boolean showForceQuit = iteration > 0; // iteration > 1 to not show
377                                                // force quit the first time
378         JFrame parent = new JFrame();
379         JButton[] buttons = { new JButton(), new JButton() };
380         JvOptionPane waitDialog = JvOptionPane.newOptionDialog();
381         JTextPane messagePane = new JTextPane();
382         messagePane.setBackground(waitDialog.getBackground());
383         messagePane.setBorder(null);
384         messagePane.setText(waitingForSaveMessage());
385         // callback as each file finishes saving
386         for (CompletableFuture<Boolean> cf : BackupFiles
387                 .savesInProgressCompletableFutures(false))
388         {
389           cf.whenComplete((ret, e) -> {
390             if (BackupFiles.hasSavesInProgress())
391             {
392               // update the list of saving files as they save too
393               messagePane.setText(waitingForSaveMessage());
394             }
395             else
396             {
397               if (!(quitCancelled()))
398               {
399                 for (int i = 0; i < buttons.length; i++)
400                 {
401                   Console.debug("DISABLING BUTTON " + buttons[i].getText());
402                   buttons[i].setEnabled(false);
403                   buttons[i].setVisible(false);
404                 }
405                 // if this is the last one then close the dialog
406                 messagePane.setText(new StringBuilder()
407                         .append(MessageManager.getString("label.all_saved"))
408                         .append("\n")
409                         .append(MessageManager
410                                 .getString("label.quitting_bye"))
411                         .toString());
412                 messagePane.setEditable(false);
413                 try
414                 {
415                   Thread.sleep(1500);
416                 } catch (InterruptedException e1)
417                 {
418                 }
419                 parent.dispose();
420               }
421             }
422           });
423         }
424
425         String[] options;
426         int dialogType = -1;
427         if (showForceQuit)
428         {
429           options = new String[2];
430           options[0] = MessageManager.getString("action.force_quit");
431           options[1] = MessageManager.getString("action.cancel_quit");
432           dialogType = JOptionPane.YES_NO_OPTION;
433           waitDialog.setResponseHandler(JOptionPane.YES_OPTION, forceQuit)
434                   .setResponseHandler(JOptionPane.NO_OPTION, cancelQuit);
435         }
436         else
437         {
438           options = new String[1];
439           options[0] = MessageManager.getString("action.cancel_quit");
440           dialogType = JOptionPane.YES_OPTION;
441           waitDialog.setResponseHandler(JOptionPane.YES_OPTION, cancelQuit);
442         }
443         waitDialog.showDialogOnTopAsync(parent, messagePane,
444                 MessageManager.getString("label.wait_for_save"), dialogType,
445                 JOptionPane.WARNING_MESSAGE, null, options,
446                 MessageManager.getString("action.cancel_quit"), true,
447                 buttons);
448
449         parent.dispose();
450         final QResponse thisWaitResponse = gotQuitResponse();
451         switch (thisWaitResponse)
452         {
453         case QUIT: // wait -- do another iteration
454           break;
455         case FORCE_QUIT:
456           doIterations = false;
457           break;
458         case CANCEL_QUIT:
459           doIterations = false;
460           break;
461         case NULL: // already cancelled
462           doIterations = false;
463           break;
464         default:
465         }
466       } // end if interactive
467
468     } // end while wait iteration loop
469     return gotQuitResponse();
470   };
471
472   private static String waitingForSaveMessage()
473   {
474     StringBuilder messageSB = new StringBuilder();
475
476     messageSB.append(MessageManager.getString("label.save_in_progress"));
477     List<File> files = BackupFiles.savesInProgressFiles(false);
478     boolean any = files.size() > 0;
479     if (any)
480     {
481       for (File file : files)
482       {
483         messageSB.append("\n\u2022 ").append(file.getName());
484       }
485     }
486     else
487     {
488       messageSB.append(MessageManager.getString("label.unknown"));
489     }
490     messageSB.append("\n\n")
491             .append(MessageManager.getString("label.quit_after_saving"));
492     return messageSB.toString();
493   }
494
495   public static void abortQuit()
496   {
497     setResponse(QResponse.NULL);
498     // executor.shutdownNow();
499   }
500
501   private static JvOptionPane quitDialog = null;
502
503   private static void setQuitDialog(JvOptionPane qd)
504   {
505     quitDialog = qd;
506   }
507
508   private static JvOptionPane getQuitDialog()
509   {
510     return quitDialog;
511   }
512
513   public static boolean quitCancelled()
514   {
515     return QuitHandler.gotQuitResponse() == QResponse.CANCEL_QUIT
516             || QuitHandler.gotQuitResponse() == QResponse.NULL;
517   }
518
519   public static boolean quitting()
520   {
521     return QuitHandler.gotQuitResponse() == QResponse.QUIT
522             || QuitHandler.gotQuitResponse() == QResponse.FORCE_QUIT;
523   }
524 }