Merge branch 'JAL-3878_ws-overhaul-3' into with_ws_overhaul-3
[jalview.git] / src / jalview / gui / ProgressBar.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 jalview.util.MessageManager;
24
25 import java.awt.BorderLayout;
26 import java.awt.Component;
27 import java.awt.GridLayout;
28 import java.awt.event.ActionEvent;
29 import java.awt.event.ActionListener;
30 import java.util.Hashtable;
31 import java.util.Map;
32
33 import javax.swing.JButton;
34 import javax.swing.JLabel;
35 import javax.swing.JPanel;
36 import javax.swing.JProgressBar;
37 import javax.swing.SwingUtilities;
38
39 /**
40  * A class to manage multiple progress bars embedded in a JPanel.
41  */
42 /*
43  * Refactored from code duplicated in AlignFrame, PCAPanel, WebserviceInfo.
44  */
45 public class ProgressBar implements IProgressIndicator
46 {
47   /*
48    * Progress bars in progress, keyed by any arbitrary long value
49    */
50   Map<Long, JPanel> progressBars;
51
52   /*
53    * Optional handlers for the progress bars
54    */
55   Map<Long, IProgressIndicatorHandler> progressBarHandlers;
56
57   /*
58    * The panel containing the progress bars - must have GridLayout
59    */
60   private JPanel statusPanel;
61
62   /*
63    * Optional label where a status update message can be written on completion
64    * of progress
65    */
66   private JLabel statusBar;
67
68   /**
69    * Constructor. Note that the container of the progress bars, and the status
70    * bar to which an optional completion message is written, should be unchanged
71    * for the lifetime of this object for consistent behaviour.
72    * 
73    * @param container
74    *          the panel holding the progress bars; must have GridLayout manager
75    * @param statusBar
76    *          an optional place to write a message when a progress bar is
77    *          removed
78    */
79   public ProgressBar(JPanel container, JLabel statusBar)
80   {
81     if (container == null)
82     {
83       throw new NullPointerException();
84     }
85     if (!GridLayout.class
86         .isAssignableFrom(container.getLayout().getClass()))
87     {
88       throw new IllegalArgumentException("Container must have GridLayout");
89     }
90     this.statusPanel = container;
91     this.statusBar = statusBar;
92     this.progressBars = new Hashtable<>();
93     this.progressBarHandlers = new Hashtable<>();
94
95   }
96
97   /**
98    * Returns true if any progress bars are still active
99    * 
100    * @return
101    */
102   @Override
103   public boolean operationInProgress()
104   {
105     if (progressBars != null && progressBars.size() > 0)
106     {
107       return true;
108     }
109     return false;
110   }
111
112   /**
113    * First call for a given id will show the message as a new progress bar. A
114    * second call with the same id will remove it. The 'removal' message is
115    * written to the status bar field (if neither is null).
116    * 
117    * To avoid progress bars being left orphaned, ensure their removal is
118    * performed in a finally block if there is any risk of an error during
119    * execution.
120    */
121   @Override
122   public void setProgressBar(final String message, final long id)
123   {
124     SwingUtilities.invokeLater(new Runnable()
125     {
126       @Override
127       public void run()
128       {
129         if (progressBars.containsKey(id))
130         {
131           /*
132            * Progress bar is displayed for this id - remove it now, and any handler
133            */
134           removeProgressBar(id);
135           if (message != null && statusBar != null)
136           {
137             statusBar.setText(message);
138           }
139         }
140         else
141         {
142           /*
143            * No progress bar for this id - add one now
144            */
145           addProgressBar(id, message);
146         }
147       }
148     });
149
150   }
151
152   /**
153    * Add a progress bar for the given id if it doesn't exist displaying the
154    * provided message. Subsequent calls do nothing.
155    * 
156    * @param id
157    *          progress bar identifier
158    * @param message
159    *          displayed message
160    */
161   @Override
162   public void addProgressBar(final long id, final String message)
163   {
164     if (progressBars.containsKey(id))
165       return;
166     JPanel progressPanel = new JPanel(new BorderLayout(10, 5));
167     progressBars.put(id, progressPanel);
168     Runnable r = () -> {
169       JProgressBar progressBar = new JProgressBar();
170       progressBar.setIndeterminate(true);
171       progressPanel.add(new JLabel(message), BorderLayout.WEST);
172       progressPanel.add(progressBar, BorderLayout.CENTER);
173       addRow(progressPanel);
174       refreshLayout();
175     };
176     if (SwingUtilities.isEventDispatchThread())
177       r.run();
178     else
179       SwingUtilities.invokeLater(r);
180   }
181
182   /**
183    * Remove a progress bar for the given id if it exists. Subsequent calls do
184    * nothing.
185    * 
186    * @param id
187    *          id of the progress bar to be removed
188    */
189   @Override
190   public void removeProgressBar(final long id)
191   {
192     JPanel progressPanel = progressBars.remove(id);
193     if (progressPanel == null)
194       return;
195     progressBarHandlers.remove(id);
196     Runnable r = () -> {
197       removeRow(progressPanel);
198       refreshLayout();
199     };
200     if (SwingUtilities.isEventDispatchThread())
201       r.run();
202     else
203       SwingUtilities.invokeLater(r);
204   }
205
206   /**
207    * Lays out progress bar container hierarchy
208    */
209   protected void refreshLayout()
210   {
211     /*
212      * lay out progress bar container hierarchy
213      */
214     Component root = SwingUtilities.getRoot(statusPanel);
215     if (root != null)
216     {
217       root.validate();
218     }
219   }
220
221   /**
222    * Remove one row with a progress bar, in a thread-safe manner
223    * 
224    * @param progressPanel
225    */
226   protected void removeRow(JPanel progressPanel)
227   {
228     synchronized (statusPanel)
229     {
230       statusPanel.remove(progressPanel);
231       GridLayout layout = (GridLayout) statusPanel.getLayout();
232       layout.setRows(layout.getRows() - 1);
233       statusPanel.remove(progressPanel);
234     }
235   }
236
237   /**
238    * Add one row with a progress bar, in a thread-safe manner
239    * 
240    * @param progressPanel
241    */
242   protected void addRow(JPanel progressPanel)
243   {
244     synchronized (statusPanel)
245     {
246       GridLayout layout = (GridLayout) statusPanel.getLayout();
247       layout.setRows(layout.getRows() + 1);
248       statusPanel.add(progressPanel);
249     }
250   }
251
252   /**
253    * Add a 'Cancel' handler for the given progress bar id. This should be called
254    * _after_ setProgressBar to have any effect.
255    */
256   @Override
257   public void registerHandler(final long id,
258       final IProgressIndicatorHandler handler)
259   {
260     final IProgressIndicator us = this;
261
262     SwingUtilities.invokeLater(new Runnable()
263     {
264       @Override
265       public void run()
266       {
267         final JPanel progressPanel = progressBars.get(id);
268         if (progressPanel == null)
269         {
270           System.err.println(
271               "call setProgressBar before registering the progress bar's handler.");
272           return;
273         }
274
275         /*
276          * Nothing useful to do if not a Cancel handler
277          */
278         if (!handler.canCancel())
279         {
280           return;
281         }
282
283         progressBarHandlers.put(id, handler);
284         JButton cancel = new JButton(
285             MessageManager.getString("action.cancel"));
286         cancel.addActionListener(new ActionListener()
287         {
288
289           @Override
290           public void actionPerformed(ActionEvent e)
291           {
292             handler.cancelActivity(id);
293             us.setProgressBar(MessageManager
294                 .formatMessage("label.cancelled_params", new Object[]
295                 { ((JLabel) progressPanel.getComponent(0)).getText() }),
296                 id);
297           }
298         });
299         progressPanel.add(cancel, BorderLayout.EAST);
300         refreshLayout();
301
302       }
303     });
304   }
305
306 }