package net.logAnalyzer.gui.messages.cellrenderers;
   
   import java.awt.Color;
   import java.awt.Component;
   import java.awt.Font;
   import java.awt.GradientPaint;
   import java.awt.Graphics;
   import java.awt.Graphics2D;
   import java.text.NumberFormat;
  
  import javax.swing.JLabel;
  import javax.swing.JTable;
  import javax.swing.UIManager;
  import javax.swing.border.Border;
  import javax.swing.border.EmptyBorder;
  import javax.swing.table.TableCellRenderer;
  
  import net.logAnalyzer.converters.LAConverter;
  import net.logAnalyzer.gui.messages.MessagesModel;
  
  /***
   * This class defines a cell renderer model displaying an horizontal percentage
   * bar. The percentage is calculated with a formula to implement in
   * {@link #computePercentage(Object, Object)} using the rendered cell value and
   * a specified base converter value.
   * 
   * @author Karim REFEYTON
   * @version 0.1
   */
  public abstract class BarRenderer extends JLabel implements TableCellRenderer {
      private static final long serialVersionUID = 1L;
  
      /***
       * Default border.
       */
      public static final Border NOFOCUS_BORDER = new EmptyBorder(1, 1, 1, 1);
  
      /***
       * Index of converter used as percentage base value.
       */
      private int logconverterBaseIndex;
  
      /***
       * <tt>true</tt> if the percentage is computed; <tt>false</tt> if an
       * error occured.
       */
      private boolean isComputed = false;
  
      /***
       * Calculating percentage to render with the progress bar.
       */
      private double percentage;
  
      /***
       * Low color.
       */
      private Color colorLow;
  
      /***
       * High color.
       */
      private Color colorHigh;
  
      /***
       * Low limit.
       */
      private double thresholdLow;
  
      /***
       * High limit.
       */
      private double thresholdHigh;
  
      /***
       * Constructs a new renderer calculating on a percentage between the
       * rendered converter and a base converter values. Renders a progress bar
       * which width is based on the percentage calculated by
       * {@link BarRenderer#computePercentage(Object, Object)}<br>
       * The color of the process bar is deduced from the following check :
       * <ul>
       * <li><tt>0 &lt;= percentage &lt;= thresholdLow</tt>: the progress bar
       * is painted with the colorLow color</li>
       * <li><tt>thresholdLow &lt; percentage &lt;= thresholdHigh</tt>: the
       * progess bar is painted with a gradient form colorLow to colorHigh color</li>
       * <li><tt>thresholdHigh &lt; percentage</tt>: the progress bar is
       * painted with the colorHigh color</li>
       * </ul>
       * 
       * @param logconverterBase
       *            Literal of the converter which value is the base of the
       *            percentage calculation.
       * @param logconverters
       *            All the converters, the base converter must be one of them.
       * @param colorLow
       *            Low color.
       * @param thresholdLow
       *            If <tt>percentage <= thresholdErrorWarn</tt> the color used
       *            is colorLow.
       * @param thresholdHigh
      *            If <tt>percentage > thresholdHigh</tt> the color used is
      *            colorHigh; otherwise is colorBase.
      * @param colorHigh
      *            High color.
      */
     public BarRenderer(String logconverterBase, LAConverter[] logconverters,
             Color colorLow, double thresholdLow, double thresholdHigh,
             Color colorHigh) {
         super();
         this.logconverterBaseIndex = -1;
         for (int i = 0; i < logconverters.length; i++) {
             if (logconverters[i].getLiteral().equals(logconverterBase)) {
                 this.logconverterBaseIndex = i;
             }
         }
         this.colorLow = colorLow;
         this.thresholdLow = thresholdLow;
         this.thresholdHigh = thresholdHigh;
         this.colorHigh = colorHigh;
         setOpaque(true);
         Font font = getFont();
         setFont(font.deriveFont(Font.PLAIN));
         setHorizontalAlignment(JLabel.RIGHT);
     }
 
     /***
      * Sets text, height, borders and colors of the cell regarding to value,
      * selection and focus.
      * 
      * @see javax.swing.table.TableCellRenderer#getTableCellRendererComponent(javax.swing.JTable,
      *      java.lang.Object, boolean, boolean, int, int)
      */
     public Component getTableCellRendererComponent(JTable table, Object value,
             boolean isSelected, boolean hasFocus, int row, int converter) {
         // The percentage is not yet computed
         isComputed = false;
         percentage = 0;
         // Sets the text
         if (value != null) {
             setText(value.toString());
         } else {
             setText("");
         }
         // Looks at the base converter in the table regarding to its data model
         // index
         MessagesModel model = (MessagesModel) table.getModel();
         if (logconverterBaseIndex >= 0) {
             // Calculates the percentage
             try {
                 percentage = computePercentage(value, model.getValueAt(row,
                         logconverterBaseIndex));
                 isComputed = true;
                 // Sets the tooltip whith percentage
                 setToolTipText(NumberFormat.getPercentInstance().format(
                         percentage));
             } catch (NumberFormatException nfe) {
                 isComputed = true;
                 setToolTipText(null);
             }
         }
         // Shows the selection and focus
         if (isSelected) {
             super.setForeground(table.getSelectionForeground());
             super.setBackground(table.getSelectionBackground());
         } else {
             super.setForeground(table.getForeground());
             super.setBackground(table.getBackground());
         }
         if (hasFocus) {
             setBorder(UIManager.getBorder("Table.focusCellHighlightBorder"));
             if (table.isCellEditable(row, converter)) {
                 super.setForeground(UIManager
                         .getColor("Table.focusCellForeground"));
                 super.setBackground(UIManager
                         .getColor("Table.focusCellBackground"));
             }
         } else {
             setBorder(NOFOCUS_BORDER);
         }
 
         return this;
     }
 
     /***
      * Calculates the percentage. Formula is specific and must be implemented by
      * concrete class.
      * 
      * @param value
      *            Rendered cell value.
      * @param baseValue
      *            Base converter value.
      * @return percentage Used to render the progress bar.
      */
     protected abstract double computePercentage(Object value, Object baseValue);
 
     /***
      * Modification to the inherited behavior.
      * 
      * @see javax.swing.JComponent#paintComponent(java.awt.Graphics)
      */
     protected void paintComponent(Graphics g) {
         super.paintComponent(g);
         if (isComputed) {
             Graphics2D g2d = (Graphics2D) g.create();
             if (isOpaque()) {
                 // Background must be drawable
                 g2d.setXORMode(getBackground());
             }
             // Creates a paint tool comparing percentage with the thresholds
             g2d.setPaint(new GradientPaint((float) (getWidth() * thresholdLow),
                     0F, colorLow, (float) (getWidth() * thresholdHigh), 0F,
                     colorHigh));
             g2d.fillRect(0, 0, (int) (getWidth() * percentage), getHeight());
             g2d.dispose();
         }
     }
 }