Merge branch 'releases/Release_2_11_4_Branch'
[jalview.git] / 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<Long, JPanel>();
93     this.progressBarHandlers = new Hashtable<Long, IProgressIndicatorHandler>();
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(String message, long id)
123   {
124     Long longId = Long.valueOf(id);
125
126     JPanel progressPanel = progressBars.get(longId);
127     if (progressPanel != null)
128     {
129       /*
130        * Progress bar is displayed for this id - remove it now, and any handler
131        */
132       progressBars.remove(id);
133       if (message != null && statusBar != null)
134       {
135         statusBar.setText(message);
136       }
137       if (progressBarHandlers.containsKey(longId))
138       {
139         progressBarHandlers.remove(longId);
140       }
141       removeRow(progressPanel);
142     }
143     else
144     {
145       /*
146        * No progress bar for this id - add one now
147        */
148       progressPanel = new JPanel(new BorderLayout(10, 5));
149
150       JProgressBar progressBar = new JProgressBar();
151       progressBar.setIndeterminate(true);
152
153       progressPanel.add(new JLabel(message), BorderLayout.WEST);
154       progressPanel.add(progressBar, BorderLayout.CENTER);
155
156       addRow(progressPanel);
157
158       progressBars.put(longId, progressPanel);
159     }
160
161     refreshLayout();
162   }
163
164   /**
165    * Lays out progress bar container hierarchy
166    */
167   protected void refreshLayout()
168   {
169     /*
170      * lay out progress bar container hierarchy
171      */
172     Component root = SwingUtilities.getRoot(statusPanel);
173     if (root != null)
174     {
175       root.validate();
176     }
177   }
178
179   /**
180    * Remove one row with a progress bar, in a thread-safe manner
181    * 
182    * @param progressPanel
183    */
184   protected void removeRow(JPanel progressPanel)
185   {
186     synchronized (statusPanel)
187     {
188       statusPanel.remove(progressPanel);
189       GridLayout layout = (GridLayout) statusPanel.getLayout();
190       layout.setRows(layout.getRows() - 1);
191       statusPanel.remove(progressPanel);
192     }
193   }
194
195   /**
196    * Add one row with a progress bar, in a thread-safe manner
197    * 
198    * @param progressPanel
199    */
200   protected void addRow(JPanel progressPanel)
201   {
202     synchronized (statusPanel)
203     {
204       GridLayout layout = (GridLayout) statusPanel.getLayout();
205       layout.setRows(layout.getRows() + 1);
206       statusPanel.add(progressPanel);
207     }
208   }
209
210   /**
211    * Add a 'Cancel' handler for the given progress bar id. This should be called
212    * _after_ setProgressBar to have any effect.
213    */
214   @Override
215   public void registerHandler(final long id,
216           final IProgressIndicatorHandler handler)
217   {
218     Long longId = Long.valueOf(id);
219     final JPanel progressPanel = progressBars.get(longId);
220     if (progressPanel == null)
221     {
222       System.err
223               .println("call setProgressBar before registering the progress bar's handler.");
224       return;
225     }
226
227     /*
228      * Nothing useful to do if not a Cancel handler
229      */
230     if (!handler.canCancel())
231     {
232       return;
233     }
234
235     progressBarHandlers.put(longId, handler);
236     JButton cancel = new JButton(MessageManager.getString("action.cancel"));
237     final IProgressIndicator us = this;
238     cancel.addActionListener(new ActionListener()
239     {
240
241       @Override
242       public void actionPerformed(ActionEvent e)
243       {
244         handler.cancelActivity(id);
245         us.setProgressBar(MessageManager.formatMessage(
246                 "label.cancelled_params",
247                 new Object[] { ((JLabel) progressPanel.getComponent(0))
248                         .getText() }), id);
249       }
250     });
251     progressPanel.add(cancel, BorderLayout.EAST);
252     refreshLayout();
253   }
254
255 }