/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of CosyBeans-Common.
    *
    * CosyBeans-Common 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.
   *
   * CosyBeans-Common 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 CosyBeans-Common.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.gui.components;
  
  import com.cosylab.gui.components.introspection.EditorsHelper;
  import com.cosylab.gui.components.table.QueueTable;
  import com.cosylab.gui.components.table.cells.DeviceCell;
  import com.cosylab.gui.components.table.cells.DoubleCell;
  import com.cosylab.gui.components.table.cells.LongCell;
  import com.cosylab.gui.components.table.cells.LongEnumCell;
  import com.cosylab.gui.components.table.cells.PatternCell;
  import com.cosylab.gui.components.table.cells.StringCell;
  import com.cosylab.gui.components.table.cells.TableCell;
  import com.cosylab.gui.components.table.renderers.DateRenderer;
  import com.cosylab.gui.components.table.renderers.DefaultTableCellRenderer;
  import com.cosylab.gui.components.table.renderers.DeviceCellRenderer;
  import com.cosylab.gui.components.table.renderers.DoubleCellEditor;
  import com.cosylab.gui.components.table.renderers.DoubleCellRenderer;
  import com.cosylab.gui.components.table.renderers.EmptyCellRenderer;
  import com.cosylab.gui.components.table.renderers.LongCellEditor;
  import com.cosylab.gui.components.table.renderers.LongCellRenderer;
  import com.cosylab.gui.components.table.renderers.LongEnumCellEditor;
  import com.cosylab.gui.components.table.renderers.LongEnumCellRenderer;
  import com.cosylab.gui.components.table.renderers.PatternCellRenderer;
  import com.cosylab.gui.components.table.renderers.StringCellRenderer;
  
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.awt.event.MouseAdapter;
  import java.awt.event.MouseEvent;
  
  import java.util.ArrayList;
  import java.util.Date;
  
  import javax.swing.JCheckBoxMenuItem;
  import javax.swing.JMenuItem;
  import javax.swing.JPopupMenu;
  import javax.swing.table.TableCellEditor;
  import javax.swing.table.TableCellRenderer;
  import javax.swing.table.TableColumn;
  import javax.swing.table.TableColumnModel;
  import javax.swing.table.TableModel;
  
  
  /**
   * <code>ObjectTable</code> includes number of usefull features over standard
   * <code>JTable</code> for users, which try to create tabel for monitoring
   * dynamic values. ObjectTable can be used same way as standard
   * <code>JTable</code>.  Following features are implemented in this table:
   * 
   * <ul>
   * <li>
   * Performance improvement with table cells are randomly updated with high
   * frequency. <code>com.cosylab.gui.components.table.QueueTable</code> is used
   * for this purpose.
   * </li>
   * <li>
   * Column hiding, user can select which columns will be displayed and which
   * not.
   * </li>
   * <li>
   * Renderers and editors are choosen for each cell individually based on cell
   * class, rather then on column calass as in JTable.
   * </li>
   * <li>
   * Renderers and editors are prepared for cells derived from
   * <code>com.cosylab.gui.components.table.cells.TableCell</code>.
   * </li>
   * </ul>
   * 
   *
   * @author <a href="mailto:ales.pucelj@cosylab.com">Ales Pucelj</a>
   * @author <a href="mailto:igor.kriznar@cosylab.com">Igor Kriznar</a>
   * @version $id$
   */
  public class ObjectTable extends QueueTable
  {
  	private static final long serialVersionUID = 1L;
  	private ArrayList<TableColumn> hiddenColumns = new ArrayList<TableColumn>();
  	private boolean allowColumnHide = true;
  	private TableCellRenderer emptyCellRenderer = new EmptyCellRenderer();
  	private boolean lastSortDescending = false;
 	private int lastComlumnSorted = 1;
 
 	private class HeaderMouseListenerImpl extends MouseAdapter
 	{
 		/**
 		 * Checks whether the event triggers popup.
 		 *
 		 * @param e MouseEvent
 		 */
 		private void performPopup(MouseEvent e)
 		{
 			if (e.isPopupTrigger()) {
 				(new ColumnChooser()).showPopup(e);
 				e.consume();
 			}
 		}
 
 		/**
 		 * @see java.awt.event.MouseListener#mouseReleased(MouseEvent)
 		 */
 		public void mouseReleased(MouseEvent e)
 		{
 			performPopup(e);
 		}
 
 		/**
 		 * @see java.awt.event.MouseListener#mouseClicked(MouseEvent)
 		 */
 		public void mouseClicked(MouseEvent e)
 		{
 			performPopup(e);
 		}
 
 		/**
 		 * @see java.awt.event.MouseListener#mousePressed(MouseEvent)
 		 */
 		public void mousePressed(MouseEvent e)
 		{
 			performPopup(e);
 		}
 	}
 
 	private class ColumnChooser extends JPopupMenu
 	{
 		private static final long serialVersionUID = 1L;
 
 		/**
 		 * Changes visibility of a column.
 		 */
 		private class ActionListenerImpl implements ActionListener
 		{
 			private int index;
 			private ObjectTable table;
 			private boolean newState;
 
 			/**
 			 * Creates a new ActionListenerImpl object.
 			 *
 			 * @param mi Model index of column.
 			 * @param ot ObjectTable.
 			 * @param how If true, column will be shown, otherwise hidded.
 			 */
 			public ActionListenerImpl(int mi, ObjectTable ot, boolean how)
 			{
 				table = ot;
 				index = mi;
 				newState = how;
 			}
 
 			/**
 			 * Changes visibiliy of a column.
 			 *
 			 * @param e event.
 			 */
 			public void actionPerformed(ActionEvent e)
 			{
 				if (newState) {
 					table.showColumn(index);
 				} else {
 					table.hideColumn(index);
 				}
 			}
 		}
 
 		private int col;
 
 		/**
 		 * Creates a new ColumnChooser object.
 		 */
 		public ColumnChooser()
 		{
 			ObjectTable owner = ObjectTable.this;
 			TableModel model = owner.getModel();
 
 			if (model instanceof ObjectTableModel) {
 				JMenuItem item = new JMenuItem("Sort ascending");
 				item.addActionListener(new ActionListener() {
 						public void actionPerformed(ActionEvent e)
 						{
 							TableModel model = getModel();
 
 							if (col > -1 && (model instanceof ObjectTableModel)) {
 								((ObjectTableModel)model).getRowModel()
 								.sortRows(col, false);
 							}
 
 							lastSortDescending = false;
 							lastComlumnSorted = col;
 						}
 					});
 				add(item);
 				item = new JMenuItem("Sort decending");
 				item.addActionListener(new ActionListener() {
 						public void actionPerformed(ActionEvent e)
 						{
 							TableModel model = getModel();
 
 							if (col > -1 && (model instanceof ObjectTableModel)) {
 								((ObjectTableModel)model).getRowModel()
 								.sortRows(col, true);
 							}
 
 							lastSortDescending = true;
 							lastComlumnSorted = col;
 						}
 					});
 				add(item);
 				add(new Separator());
 			}
 
 			int n = model.getColumnCount();
 
 			for (int i = 0; i < n; i++) {
 				JCheckBoxMenuItem item = new JCheckBoxMenuItem(model
 					    .getColumnName(i));
 
 				boolean isHidden = (owner.findHiddenColumn(i) != null);
 
 				item.setSelected(!isHidden);
 
 				item.addActionListener(new ActionListenerImpl(i, owner, isHidden));
 				add(item);
 			}
 		}
 
 		/**
 		 * DOCUMENT ME!
 		 *
 		 * @param ev DOCUMENT ME!
 		 */
 		public void showPopup(MouseEvent ev)
 		{
 			col = getTableHeader().columnAtPoint(ev.getPoint());
 
 			if (col > -1) {
 				col = getTableHeader().getColumnModel().getColumn(col)
 					.getModelIndex();
 			}
 
 			show(ev.getComponent(), ev.getX(), ev.getY());
 		}
 	}
 
 	/**
 	 * Constructor for ObjectTable.
 	 */
 	public ObjectTable()
 	{
 		super();
 		getTableHeader().addMouseListener(new HeaderMouseListenerImpl());
 	}
 
 	/**
 	 * Constructor for ObjectTable.
 	 *
 	 * @param dm
 	 */
 	public ObjectTable(TableModel dm)
 	{
 		super(dm);
 		getTableHeader().addMouseListener(new HeaderMouseListenerImpl());
 	}
 
 	/**
 	 * Constructor for ObjectTable.
 	 *
 	 * @param dm
 	 * @param cm
 	 */
 	public ObjectTable(TableModel dm, TableColumnModel cm)
 	{
 		super(dm, cm);
 		getTableHeader().addMouseListener(new HeaderMouseListenerImpl());
 	}
 
 	/**
 	 * Creates default renderers as defined in renderers package. This only
 	 * provides basic rendering support. Custom renderers should be added for
 	 * displaying more complex types.
 	 *
 	 * @see javax.swing.JTable#createDefaultRenderers()
 	 */
 	@SuppressWarnings("unchecked")
 	protected void createDefaultRenderers()
 	{
 		super.createDefaultRenderers();
 
 		defaultRenderersByColumnClass.put(DoubleCell.class,
 		    new DoubleCellRenderer());
 
 		defaultRenderersByColumnClass.put(LongCell.class, new LongCellRenderer());
 
 		defaultRenderersByColumnClass.put(LongEnumCell.class,
 		    new LongEnumCellRenderer());
 
 		defaultRenderersByColumnClass.put(StringCell.class,
 		    new StringCellRenderer());
 
 		defaultRenderersByColumnClass.put(PatternCell.class,
 		    new PatternCellRenderer());
 
 		defaultRenderersByColumnClass.put(DeviceCell.class,
 		    new DeviceCellRenderer());
 
 		defaultRenderersByColumnClass.put(Date.class, new DateRenderer());
 
 		defaultRenderersByColumnClass.put(TableCell.class,
 		    new DefaultTableCellRenderer());
 
 		//defaultRenderersByColumnClass.remove(Boolean.class);
 	}
 
 	/**
 	 * Creates default editors as defined in editors package. This only
 	 * provides basic editing support. Custom editors should be added for
 	 * editing more complex types.
 	 *
 	 * @see javax.swing.JTable#createDefaultEditors()
 	 */
 	@SuppressWarnings("unchecked")
 	protected void createDefaultEditors()
 	{
 		super.createDefaultEditors();
 
 		defaultEditorsByColumnClass.put(DoubleCell.class, new DoubleCellEditor());
 
 		defaultEditorsByColumnClass.put(LongCell.class, new LongCellEditor());
 
 		defaultEditorsByColumnClass.put(LongEnumCell.class,
 		    new LongEnumCellEditor());
 
 		defaultEditorsByColumnClass.put(DeviceCell.class,
 		    new DeviceCellRenderer());
 	}
 
 	/**
 	 * Trys to return cell renderer on cell class, if this fails then try to
 	 * find rendere by default JTable procedure.
 	 *
 	 * @see javax.swing.JTable#getCellRenderer(int, int)
 	 */
 	public TableCellRenderer getCellRenderer(int row, int column)
 	{
         TableColumn tableColumn = getColumnModel().getColumn(column);
         
         // renderer defined for the column
         TableCellRenderer renderer = tableColumn.getCellRenderer();
         
         if (renderer!=null) {
         	return renderer;
         }
         
         // checks for default renderer only if model has specified some particular
         // column class, Object.class is assumed to be default choice, thus ignored.
 
         Class cl= getColumnClass(column);
         if (cl!=Object.class) {
         	renderer= getDefaultRenderer(cl);
         }
         
         if (renderer!=null) {
         	return renderer;
         }
 
         // tries to find renderer based on cell value class
         int c = convertColumnIndexToModel(column);
 		Object cell = getModel().getValueAt(row, c);
 
 		if (cell == null) {
 			return emptyCellRenderer;
 		}
 
 		renderer = getDefaultRenderer(cell.getClass());
 
 		// tryes to use helper class to produce simple renderer for special class
 		if (renderer == null) {
 			renderer = EditorsHelper.getTableCellRendererForClass(cell.getClass());
 		}
 
 		if (renderer == null) {
 			renderer = super.getCellRenderer(row, column);
 		}
 
 		return renderer;
 	}
 
 	/**
 	 * Trys to return cell editor on cell class, if this fails then try to find
 	 * editor by default JTable procedure.
 	 *
 	 * @see javax.swing.JTable#getCellRenderer(int, int)
 	 */
 	public TableCellEditor getCellEditor(int row, int column)
 	{
         TableColumn tableColumn = getColumnModel().getColumn(column);
         
         // renderer defined for the column
         TableCellEditor editor = tableColumn.getCellEditor();
         
         if (editor!=null) {
         	return editor;
         }
         
         // checks for default renderer only if model has specified some particular
         // column class, Object.class is assumed to be default choice, thus ignored.
 
         Class cl= getColumnClass(column);
         if (cl!=Object.class) {
         	editor= getDefaultEditor(cl);
         }
         
         if (editor!=null) {
         	return editor;
         }
 
         // tries to find renderer based on cell value class
         int c = convertColumnIndexToModel(column);
 		Object cell = getModel().getValueAt(row, c);
 
 		if (cell == null) {
 			return super.getCellEditor(row, column);
 		}
 
 		editor = getDefaultEditor(cell.getClass());
 
 		// tryes to use helper class to produce simple renderer for special class
 		if (editor == null) {
 			editor = EditorsHelper.getTableCellEditorForClass(cell.getClass());
 		}
 
 		if (editor == null) {
 			editor = super.getCellEditor(row, column);
 		}
 
 		return editor;
 
 	}
 
 	protected boolean validColumnIndex(int index)
 	{
 		return ((index >= 0) && (index < getModel().getColumnCount()));
 	}
 
 	/**
 	 * Hides column at specified model index.
 	 *
 	 * @param index of column to hide.
 	 */
 	public void hideColumn(int index)
 	{
 		if (validColumnIndex(index) && allowColumnHide) {
 			TableColumn tc = getColumn(getModel().getColumnName(index));
 			getColumnModel().removeColumn(tc);
 			hiddenColumns.add(tc);
 		}
 	}
 
 	/**
 	 * Helper method to find hidden column for given model index.
 	 *
 	 * @param modelIndex of the column.
 	 *
 	 * @return Instance of TableColumn or null if not found.
 	 */
 	protected TableColumn findHiddenColumn(int modelIndex)
 	{
 		int n = hiddenColumns.size();
 
 		for (int i = 0; i < n; i++) {
 			TableColumn tc = hiddenColumns.get(i);
 
 			if (tc.getModelIndex() == modelIndex) {
 				return tc;
 			}
 		}
 
 		return null;
 	}
 
 	/**
 	 * Shows column at given model index.
 	 *
 	 * @param index index of column to show.
 	 */
 	public void showColumn(int index)
 	{
 		if (validColumnIndex(index) && allowColumnHide) {
 			TableColumn tc = findHiddenColumn(index);
 
 			if (tc == null) {
 				return;
 			}
 
 			getColumnModel().addColumn(tc);
 			hiddenColumns.remove(tc);
 			getColumnModel().moveColumn(getColumnCount() - 1, index);
 		}
 	}
 
 	/**
 	 * Shows all hidden columns.
 	 */
 	protected synchronized void showHiddenColumns()
 	{
 		for (int i = 0; i < hiddenColumns.size(); i++) {
 			getColumnModel().addColumn(hiddenColumns.get(i));
 		}
 
 		hiddenColumns.clear();
 	}
 
 	/**
 	 * Returns whether table allows hiding of columns.
 	 *
 	 * @return true if hiding is allowed.
 	 */
 	public boolean getAllowColumnHide()
 	{
 		return allowColumnHide;
 	}
 
 	/**
 	 * Sets whether table allows hiding of columns.
 	 *
 	 * @param value True to allow hiding of columns.
 	 */
 	public void setAllowColumnHide(boolean value)
 	{
 		allowColumnHide = value;
 	}
 
 	/* (non-Javadoc)
 	 * @see javax.swing.JTable#createDefaultColumnsFromModel()
 	 */
 	public void createDefaultColumnsFromModel()
 	{
 		if (hiddenColumns != null) {
 			hiddenColumns.clear();
 		}
 
 		super.createDefaultColumnsFromModel();
 	}
 
 	/**
 	 * Repeats the sorting that was applied last.
 	 *
 	 */
 	public void repeatLastSort()
 	{
 		TableModel model = getModel();
 
 		if (lastComlumnSorted > -1 && (model instanceof ObjectTableModel)) {
 			((ObjectTableModel)model).getRowModel().sortRows(lastComlumnSorted,
 			    lastSortDescending);
 		}
 	}
 }
 
 /* __oOo__ */