/*
    * $HeadURL: $
    * $Date: $
    * $Revision: $
    * $Author: $
    * 
    * Copyright (c) 2005 MindTree Consulting Ltd. 
    * 
    * This file is part of Insight.
   * 
   * Insight is free software: you can redistribute it and/or modify it under the 
   * terms of the GNU General Public License as published by the Free Software 
   * Foundation, either version 3 of the License, or (at your option) any later 
   * version.
   * 
   * Insight is distributed in the hope that it will be useful, but 
   * WITHOUT ANY WARRANTY; without even the implied warranty of 
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General 
   * Public License for more details.
   * 
   * You should have received a copy of the GNU General Public License along with 
   * Insight.  If not, see <http://www.gnu.org/licenses/>.
   */
  package com.mindtree.techworks.insight.gui.widgets;
  
  import java.awt.Component;
  import java.awt.Dimension;
  import java.awt.GridBagConstraints;
  import java.awt.GridBagLayout;
  import java.awt.Toolkit;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.util.ArrayList;
  
  import javax.swing.JPanel;
  import javax.swing.JProgressBar;
  import javax.swing.JSeparator;
  import javax.swing.Timer;
  
  import com.mindtree.techworks.insight.InsightConstants;
  
  /**
  *
  * The <code>StatusBar</code> class is a GUI component that may be used for
  * displaying status messages or progress indicator with static text. This status bar number of partitions declared
  * in InsightConstants plus 1. The last partition is meant for statistics display such as line number, current page
  * and total number of pages of event summary e.t.c. Each partition contains a "indeterminate" JProgressBar that supports
  * static text and/or a progress indicator. 
  * 
  * @author  Regunath B
  * @version 1.0, 04/12/28
  */
  
  public class StatusBar extends JPanel {
  	
  	/**
  	 * Used for object serialization
  	 */
  	private static final long serialVersionUID = -6654725016958741987L;
  	
  	/*
  	 * Useful constants for the preferred dimensions of this StatusBar
  	 */
  	private static final int WIDTH = 900;
  	private static final int HEIGHT = 20;
  	private static final int SEPARATOR_WIDTH = 2;
  	
  	/*
  	 * The maximum length of the display text for this StatusBar
  	 */
  	private static final int MAX_TEXT_LENGTH = 100;
  		
  	/*
  	 * Singleton static instance of this class
  	 */
  	private static StatusBar instance;
  	
  	/*
  	 * List that contains the JProgressBar instances 
  	 */
  	private ArrayList progressBarList;
  	
  	/*
  	 * Layout definition.
  	 */
  	private GridBagLayout gl;
  	private GridBagConstraints gc;
  	
  	/*
  	 * Count of GUI components displayed on this JPanel
  	 */
  	private int componentCount = -1;
  	
  	/**
  	 * Private constructor to prevent multiple instances
  	 * @see #getInstance() to obtain instance of this class
  	 */
  	private StatusBar(int partitionCount) {
  		gl = new GridBagLayout();
 		gc = new GridBagConstraints();
 		setLayout(gl);
 		
 		progressBarList = new ArrayList(partitionCount);
 
 		for (int i = 0; i < partitionCount; i++) {
 			JProgressBar progressBar = new JProgressBar(JProgressBar.HORIZONTAL);
 			initializeProgressBar(progressBar);
 			progressBarList.add(progressBar);
 		}
 		setPreferredSize(getIdealPreferredSize());
 	}
 	
 	/**
 	 * Returns the singleton instance of this class.
 	 * @return instance of this class
 	 */
 	public synchronized static final StatusBar getInstance() {
 		if (instance == null) {
 			instance = new StatusBar(InsightConstants.SB_PARTITION_COUNT + 1);
 		}
 		return instance;
 	}
 	
 	/**
 	 * Sets the display text of the partition identified by the specified partition index
 	 * The display is automatically cleared after a lease duration if <code>animate</code>
 	 * is false.
 	 * @param partitionIndex valid 0 based index of the partition
 	 * @param text the Text string to be displayed
 	 * @param animate true if the "indeterminate" animation of the progress indicator is needed, false otherwise
 	 */
 	public void setDisplayText(int partitionIndex, String text, boolean animate) {
 		if (partitionIndex >= InsightConstants.SB_PARTITION_COUNT) {
 			return;
 		}
 		this.setDisplayTextPrivate(partitionIndex, text, animate, true);
 	}
 	
 	/**
 	 * Sets the specified text in the statistics display partition of the Status bar. Note that the text is not
 	 * automatically cleared after the usual default duration
 	 * @param text the text to be displayed in the statistics partition
 	 */
 	public void setStatisticsDisplayText(String text) {
 		this.setDisplayTextPrivate(InsightConstants.SB_PARTITION_COUNT, text, false, false);
 	}
 
 	/**
 	 * Clears the statictics display text i.e the text displayed in the
 	 * partition dedicated for statistics display.
 	 */
 	public void clearStatisticsDisplayText() {
 		this.clearDisplayPrivate(InsightConstants.SB_PARTITION_COUNT);
 	}
 
 	/**
 	 * Clears the display text of the partition identified by the specified partition index
 	 * @param partitionIndex valid 0 based index of the partition
 	 */
 	public void clearDisplay(int partitionIndex) {
 		if (partitionIndex >= InsightConstants.SB_PARTITION_COUNT) {
 			return;
 		}
 		this.clearDisplayPrivate(partitionIndex);
 	}
 	
 	/**
 	 * Helper method that returns the best size between this component's preferred size and that ideal 
 	 * for the display size
 	 * @return Dimension most appropriate for this widget
 	 */
 	private Dimension getIdealPreferredSize() {
 		Dimension dimension = null;
 		Dimension screenDim = Toolkit.getDefaultToolkit().getScreenSize();
 		dimension = new Dimension((int)Math.min(screenDim.getWidth() - 50, WIDTH),
 				HEIGHT);
 		return dimension;		
 	}        		
 	
 	/**
 	 * Helper method that clears the display text of the partition identified by the specified partition index
 	 * @param partitionIndex valid 0 based index of the partition
 	 */
 	private void clearDisplayPrivate(int partitionIndex) {
 		JProgressBar progressBar = (JProgressBar)progressBarList.get(partitionIndex);
 		progressBar.setString("");
 		progressBar.setIndeterminate(false);						
 	}
 	
 	/**
 	 * Helper method to set the display text in the status bar partitions.
 	 * @see #setDisplayText(int, String, boolean)
 	 * @see #setStatisticsDisplayText(String)
 	 * @param partitionIndex valid 0 based index of the partition
 	 * @param text the Text string to be displayed
 	 * @param animate true if the "indeterminate" animation of the progress indicator is needed, false otherwise
 	 * @param enableDisplayLease true if the display is leased for the default duration, false otherwise
 	 */
 	private void setDisplayTextPrivate(int partitionIndex, String text, boolean animate, boolean enableDisplayLease) {
 		JProgressBar progressBar = (JProgressBar)progressBarList.get(partitionIndex);
 		text = text.substring(0,Math.min(text.length(), MAX_TEXT_LENGTH));
 		progressBar.setString(text);
 		int stringSizeInPixels = progressBar.getFontMetrics(progressBar.getFont()).stringWidth(text);
 		if (stringSizeInPixels > progressBar.getWidth()) {
 			// Indicate to the LayoutManager that the progress bar will need to be resized to 
 			// accomodate the text
 			progressBar.invalidate();
 			this.validate();
 		}
 		progressBar.setIndeterminate(animate);
 		if (!animate && enableDisplayLease) { // Start the time to clear the text after the lease duration
 			Timer timer = new Timer(InsightConstants.DISPLAY_INTERVAL, new DisplayLease(partitionIndex));
 			timer.setRepeats(false);
 			timer.start();
 		}		
 	}
 
 	/**
 	 * Helper method that initializes and adds the specified JProgressBar to this StatusBar 
 	 * @param progressBar the JProgressBar to initialize
 	 */
 	private void initializeProgressBar(JProgressBar progressBar) {
 		JSeparator separator = new JSeparator(JSeparator.VERTICAL);
 		separator.setPreferredSize(new Dimension(SEPARATOR_WIDTH,HEIGHT));
 		addComponent(separator,++componentCount,0,0,0);
 		progressBar.setBorderPainted(false);
 		progressBar.setStringPainted(true);
 		progressBar.setString("");
 		addComponent(progressBar,++componentCount,0,1,0);
 	}	
 	
 	/**
 	 * Adds the specified component to this panel using the specified constraints.
 	 **/
 	private final void addComponent(Component c, int gridx, int gridy, int weightx,
 		int weighty) {
 		gc.fill = GridBagConstraints.HORIZONTAL;
 		gc.anchor = GridBagConstraints.NORTHWEST;
 		gc.gridx = gridx;
 		gc.gridy = gridy;
 		gc.weightx = weightx;
 		gc.weighty = weighty;
 		gl.setConstraints( c, gc);
 		add(c);
 	}
 	
 	/**
 	 * Helper class that implements the ActionListener interface for notifications from
 	 * the Timer. Clears the display of the respective status bar partition on notification. 
 	 */
 	private class DisplayLease implements ActionListener {
 		/*
 		 * The partition index to clear
 		 */
 		private int partitionIndex;
 		
 		/**
 		 * Constructor for this class
 		 * @param partitionIndex the parttion index to be cleared after the display lease expires
 		 */
 		public DisplayLease(int partitionIndex) {
 			this.partitionIndex = partitionIndex;
 		}
 		
 		/**
 		 * ActionListener interface impementation
 		 * @see ActionListener#actionPerformed(java.awt.event.ActionEvent)
 		 */
 		public void actionPerformed(ActionEvent e) {
 			clearDisplay(this.partitionIndex);
 		}		
 	}
 	
 }