/*
    *  XNap - A P2P framework and client.
    *
    *  See the file AUTHORS for copyright information.
    *
    *  This program 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.
    *
   *  This program 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 this program; if not, write to the Free Software
   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   */
  
  package org.xnap.gui.table;
  
  import java.awt.event.InputEvent;
  import java.awt.event.MouseAdapter;
  import java.awt.event.MouseEvent;
  import java.awt.event.MouseMotionListener;
  import java.util.Enumeration;
  
  import javax.swing.JPopupMenu;
  import javax.swing.JTable;
  import javax.swing.JTree;
  import javax.swing.table.JTableHeader;
  import javax.swing.tree.TreePath;
  
  import org.xnap.gui.util.GUIHelper;
  
  /***
   * TableHeaderHandler class handles the mouse events invoked by clicking
   * on the header portion of the JTable.
   */
  public class TableHeaderHandler extends MouseAdapter 
      implements MouseMotionListener {
  
      // --- Data Field(s) ---
  
      private JTable jta;
      private JTableHeader header;
      private JTree jt;
      private JPopupMenu jpm;
      private SortButtonRenderer renderer;
      private SortableModel stm;
      private TableHeaderListener thl;
      
      private TreePath[] selectedPaths;
      private Enumeration expandedLeafs;
  
      /***
       * Set to true, when the user has pressed a button but not yet
       * dragged it.
       */
      private boolean sorting = false;
  
      // --- Constructor(s) ---
  
      /***
       * 
       */
      public TableHeaderHandler(JTable jta, SortableModel stm, JPopupMenu jpm)
      {
  		this.jta = jta;
  		this.header = jta.getTableHeader();
  		this.stm = stm;
  		this.jpm = jpm;
  
  		renderer = new SortButtonRenderer(header.getDefaultRenderer());
  		header.setDefaultRenderer(renderer);
  
  		header.setReorderingAllowed(true);
  		header.setResizingAllowed(true);
      }
  
      // --- Method(s) ---
  
      /***
       * Installs a TableHeaderHandler to <code>jta</code>. The handler
       * takes care of sorting and resizing.
       *
       * <p>The SortableTableModel parameter is needed for the JTreeTable, 
       * because it uses a TreeTableModelAdapter that wraps around 
       * the real TableModel.
       */
      public static TableHeaderHandler install(JTable jta, JPopupMenu jpm,
  											 SortableModel stm)
      {
          JTableHeader jth = jta.getTableHeader();
  		TableHeaderHandler l = new TableHeaderHandler(jta, stm, jpm);
          jth.addMouseListener(l);
          jth.addMouseMotionListener(l);
  
  		return l;
     }
 
     public static TableHeaderHandler install(JTable jta, JPopupMenu jpm)
     {
 		return install(jta, jpm, (SortableModel)jta.getModel());
     }
 
     /***
      * Installs listener.
      */
     public static TableHeaderHandler install(JTable jta)
     {
 		return install(jta, null);
     }
 
     public void mousePressed(MouseEvent e)
     {
 		if (e.isPopupTrigger()) {
 			showPopupMenu(e);
 		}
 		else {
 			int col = header.columnAtPoint(e.getPoint());
 			renderer.selectColumn(col);
 			header.repaint();
 	    
 			sorting = true;
 		}
 
 		setAutoResizeMode(e);
     }
 
     public void mouseReleased(MouseEvent e) 
     {
 		if (e.isPopupTrigger()) {
 			showPopupMenu(e);
 		}
 		else if (sorting) {
 			int col = header.columnAtPoint(e.getPoint());
 			if (jta.isEditing()) {
 				jta.getCellEditor().stopCellEditing();
 			}
 			sortByColumn(col);
 
 			if (thl != null) {
 				thl.sortedColumnChanged();
 			}
 			sorting = false;
 			renderer.selectColumn(-1);
 			header.repaint();
 		}
 		else {
 			if (thl != null) {
 				thl.columnWidthChanged();
 			}
 		}
     }
 
     public void mouseDragged(MouseEvent e) 
     {
 		if (sorting) {
 			// abort sorting
 			sorting = false;
 	    
 			renderer.selectColumn(-1);
 			header.repaint();
 		}
 
 		setAutoResizeMode(e);
     }
 
     public void mouseMoved(MouseEvent e) 
     {
     }
 
     /***
      * Sets the auto resize mode of the table depending on a modifier key.
      */
     private void setAutoResizeMode(MouseEvent e)
     {
 		if ((e.getModifiers() & InputEvent.SHIFT_MASK) != 0) {
 			jta.setAutoResizeMode(JTable.AUTO_RESIZE_NEXT_COLUMN);
 		}
 		else if ((e.getModifiers() & InputEvent.CTRL_MASK) != 0) {
 			jta.setAutoResizeMode(JTable.AUTO_RESIZE_ALL_COLUMNS);
 		}
 		else {
 			jta.setAutoResizeMode(JTable.AUTO_RESIZE_SUBSEQUENT_COLUMNS);
 		}
     }
 
     public void setListener(TableHeaderListener thl)
     {
 		this.thl = thl;
     }
 
     public void setTree(JTree jt)
     {
 		this.jt = jt;
     }
 
     /***
      * Displays the popup menu.
      */
     public void showPopupMenu(MouseEvent e)
     {
 		if (jpm != null) {
 			header.setDraggedColumn(null);
 			header.setResizingColumn(null);
 			GUIHelper.showPopupMenu(jpm, e.getComponent(), e.getX(), e.getY());
 		}
     }
 
     /***
      *
      */
     public void sortByColumn(int column)
     {
 		int modelIndex = jta.convertColumnIndexToModel(column);
 
 		boolean ascending;
 		if (stm.getSortedColumn() == modelIndex) {
 			// keep old sort order
 			ascending = stm.isSortedAscending();
 		}
 		else if (stm.getColumnClass(modelIndex) == String.class) {
 			// sort strings ascending
 			ascending = true;
 		}
 		else {
 			// sort descending by default
 			ascending = false;
 		}
 
 		// revert if the same column was resorted
 		boolean revert = (stm.getSortedColumn() == modelIndex);
 
 		storeSelections();
 
 		ascending = stm.sortByColumn(modelIndex, ascending, revert);
 		renderer.setSortedColumn(column, ascending);
 
 		restoreSelections();
     }
 
     public void storeSelections() 
     {
 		if (jt != null) {
 			selectedPaths = jt.getSelectionPaths();
 			expandedLeafs = jt.getExpandedDescendants
 				(new TreePath(jt.getModel().getRoot()));
 		}
     }
 
     public void restoreSelections() {
 		if (jt != null) {
 			if (expandedLeafs != null) {
 				while (expandedLeafs.hasMoreElements()) {
 					TreePath path = (TreePath)expandedLeafs.nextElement();
 					jt.expandPath(path);
 				}
 			}
 			if (selectedPaths != null) {
 				jt.addSelectionPaths(selectedPaths);
 			}
 		}
     }
 
 }