// Copyright 2004, FreeHEP.
   package org.lcsim.plugin.browser.sort;
   
   import java.awt.Component;
   import java.awt.Graphics;
   import java.beans.PropertyChangeEvent;
   import java.beans.PropertyChangeListener;
   
   import javax.swing.Icon;
  import javax.swing.JLabel;
  import javax.swing.JTable;
  import javax.swing.table.JTableHeader;
  import javax.swing.table.TableModel;
  import org.freehep.swing.table.TableColumnHeaderListener;
  import org.freehep.swing.table.TableHeaderCellRenderer;
  
  /**
   * Utility to add a sorter for columns to a JTable which has a SortableTableModel.
   * <p>
   * Example of use:
   * <pre>
   *  TableModel model = ...
   *  DefaultSortableTableModel sm = new DefaultSortableTableModel(model);
   *  JTable table = new JTable(sm);
   *  TableSorter sorter = new TableSorter(table);
   * </pre>
   * @author Mark Donszelmann
   * @author Tony Johnson
   * @version $Id: TableSorter.java,v 1.1 2007/06/01 23:58:58 tonyj Exp $
   * @see org.freehep.swing.table.SortableTableModel
   */
  public class TableSorter
  {
     private static Icon downTriangle = new Triangle(false);
     private static Icon upTriangle = new Triangle(true);
     
     private SortableTableModel model;
     private JTableHeader header;
     
     /**
      * Create a TableSorter. The table will initially be unsorted.
      * @param table The table to be sorted
      */
     public TableSorter(JTable table)
     {
        table.addPropertyChangeListener("model",new ModelChangeListener());
        modelChanged(table.getModel());
        header = table.getTableHeader();
        header.addMouseListener(new HeaderListener());
        header.setDefaultRenderer(new HeaderRenderer());
     }
     
     /**
      * Create a TableSorter. The table will initially be sorted in ascending order by the given column.
      * @param table The table to be sorted.
      * @param column The column on which to sort, or <CODE>SortableTableModel.UNSORTED</CODE>
      */
     public TableSorter(JTable table, int column)
     {
        this(table, column, true);
     }
     
     /**
      * Create a TableSorter specifiying initial sorting parameters.
      * @param table The table to be sorted.
      * @param column The column on which to sort, or <CODE>SortableTableModel.UNSORTED</CODE>
      * @param ascending <CODE>true</CODE> for ascending order, <CODE>false</CODE> for descending order
      */
     public TableSorter(JTable table, int column, boolean ascending)
     {
        this(table);
        sort(column,ascending);
     }
     
     /**
      * Find the current sort column.
      * @return The current sort column, or <CODE>SortableTableModel.UNSORTED</CODE>
      */
     public int getSortOnColumn()
     {
        return model == null ? SortableTableModel.UNSORTED : model.getSortOnColumn();
     }
     
     /**
      * Set the sort column.
      * @param column The column on which to sort, or <CODE>SortableTableModel.UNSORTED</CODE>
      */
     public void setSortOnColumn(int column)
     {
        if (model != null) model.sort(column,true);
     }
     
     /**
      * Get the current sort order.
      * @return <CODE>true</CODE> if ascending order, <CODE>false</CODE> for descending order.
      */
     public boolean isSortAscending()
     {
        return model == null ? true : model.isSortAscending();
    }
    
    /**
     * Set the current sort order.
     * @param ascending <CODE>true</CODE> for ascending order, <CODE>false</CODE> for descending order
     */
    public void setSortAscending(boolean ascending)
    {
       if (model != null) model.sort(model.getSortOnColumn(),ascending);
    }
    
    private void sort(int sortOnColumn, boolean sortAscending)
    {
       if (model != null)
       {
          model.sort(sortOnColumn, sortAscending);
          header.resizeAndRepaint();
       }
    }
    private void modelChanged(TableModel model)
    {
       this.model = model instanceof SortableTableModel ? (SortableTableModel) model : null;
    }
    private class ModelChangeListener implements PropertyChangeListener
    {
       public void propertyChange(PropertyChangeEvent evt)
       {
          modelChanged((TableModel) evt.getNewValue());
       }
    }
    private class HeaderListener extends TableColumnHeaderListener
    {
       
       public void headerClicked(JTable table, int col)
       {
          if (model != null)
          {
             if (col != model.getSortOnColumn())
             {
                sort(col, true);
             }
             else
             {
                sort(model.getSortOnColumn(), !model.isSortAscending());
             }
          }
       }
    }
    
    private class HeaderRenderer extends TableHeaderCellRenderer
    {
       
       public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int col)
       {
          JLabel label = (JLabel) super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, col);
          if (model != null && table.convertColumnIndexToModel(col) == model.getSortOnColumn())
          {
             label.setIcon(model.isSortAscending() ? downTriangle : upTriangle);
          }
          else
          {
             label.setIcon(null);
          }
          return label;
       }
    }
    private static class Triangle implements Icon
    {
       private boolean up;
       private static final int size = 16;
       private static final int[] xxdown = { 3 , 12, 7 };
       private static final int[] yydown = { 5 , 5, 10 };
       private static final int[] xxup = { 2 , 12, 7 };
       private static final int[] yyup = { 10 , 10, 4 };
       Triangle(boolean up)
       {
          this.up = up;
       }
       
       public int getIconHeight()
       {
          return size;
       }
       
       public int getIconWidth()
       {
          return size;
       }
       
       public void paintIcon(Component c, Graphics g, int x, int y)
       {
          int[] xp = new int[3];
          int[] yp = new int[3];
          for (int i=0; i<3; i++)
          {
             xp[i] = x + (up ? xxup[i] : xxdown[i]);
             yp[i] = y + (up ? yyup[i] : yydown[i]);
          }
          g.setColor(c.getForeground());
          g.fillPolygon(xp,yp,3);
       }
    }
 }