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<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 }