/*
    * 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.introspection;
  
  import java.awt.CardLayout;
  import java.awt.event.WindowAdapter;
  import java.awt.event.WindowEvent;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Comparator;
  import java.util.Map;
  
  import javax.swing.JFrame;
  import javax.swing.JPanel;
  import javax.swing.JScrollPane;
  import javax.swing.JTable;
  import javax.swing.table.AbstractTableModel;
  
  
  /**
   * A TableModel implementation that handles key-value maps to be used with
   * JTable
   *
   * @author <a href="mailto:miha.kadunc@cosylab.com">Miha Kadunc</a>
   * @version $id$
   */
  public class MapTableModel extends AbstractTableModel
  {
  
  	private static final long serialVersionUID = 1L;
  
  	String[] columns = { "key", "value", "info" };
  
  	/** flags for keys and values */
  	boolean[] editable = { false, true, false };
  	ArrayList keys = null;
  	ArrayList values = null;
  	ArrayList keyInfo = null;
  	int[] colMap = { 0, 1, 2 };
  
  	/** Forces table to sort map by key names (key.toString()). */
  	private boolean sortByKeyName = true;
  
  	private class KeyComparator implements Comparator
  	{
  		/* (non-Javadoc)
  		    * @see java.util.Comparator#compare(java.lang.Object, java.lang.Object)
  		    */
  		public int compare(Object o1, Object o2)
  		{
  			return String.valueOf(o1).compareTo(String.valueOf(o2));
  		}
  	}
  
  	/**
  	 * DOCUMENT ME!
  	 *
  	 * @param args String[]
  	 */
  	public static void main(String[] args)
  	{
  		JFrame frame = new JFrame();
  		JPanel panel = new JPanel();
  		MapTableModel model = new MapTableModel(new String[]{ "property", "value" });
  		JTable table = new JTable(model);
  		JScrollPane pane = new JScrollPane(table);
  
  		model.setKeys(new String[]{ "1", "2", "3" });
  		model.setValues(new String[]{ "val1", "val2", "val3" });
  
  		panel.setLayout(new CardLayout());
  		panel.add(pane, "table");
  		frame.setContentPane(panel);
  		frame.setBounds(100, 100, 300, 200);
  
  		frame.addWindowListener(new WindowAdapter() {
  				/**
  				 * @see java.awt.event.WindowAdapter#windowClosed(WindowEvent)
  				 */
  				public void windowClosed(WindowEvent e)
  				{
 					System.exit(0);
 				}
 			});
 		frame.setVisible(true);
 	}
 
 	/**
 	 * Creation date: (3.1.2002 17:04:55)
 	 */
 	public MapTableModel()
 	{
 		keys = new ArrayList();
 		values = new ArrayList();
 		fireTableStructureChanged();
 	}
 
 	/**
 	 * Creation date: (3.1.2002 17:04:55)
 	 *
 	 * @param columnNames DOCUMENT ME!
 	 */
 	public MapTableModel(String[] columnNames)
 	{
 		this();
 
 		if (columnNames.length > 2) {
 			keyInfo = new ArrayList();
 		}
 
 		columns = columnNames;
 	}
 
 	/**
 	 * Creation date: (3.1.2002 17:04:55)
 	 *
 	 * @param columnNames String[]
 	 * @param keys Object[]
 	 */
 	public MapTableModel(String[] columnNames, Object[] keys)
 	{
 		this(columnNames);
 		setKeys(keys);
 	}
 
 	/**
 	 * Creation date: (3.1.2002 17:04:55)
 	 *
 	 * @param columnNames String[]
 	 * @param map Map
 	 */
 	public MapTableModel(String[] columnNames, Map map)
 	{
 		this(columnNames);
 		setMap(map);
 	}
 
 	/**
 	 * Creation date: (3.1.2002 16:34:43)
 	 *
 	 * @param index int
 	 * @param map Map
 	 */
 	public void addMap(int index, Map map)
 	{
 		internalAddMap(index, map);
 		fireTableRowsInserted(index, index + map.size());
 	}
 
 	/**
 	 * Creation date: (3.1.2002 16:34:43)
 	 *
 	 * @param map Map
 	 */
 	public void addMap(Map map)
 	{
 		addMap(keys.size(), map);
 	}
 
 	/**
 	 * Creation date: (3.1.2002 16:34:43)
 	 *
 	 * @param index int
 	 * @param key java.lang.Object
 	 * @param value java.lang.Object
 	 */
 	public void addRow(int index, Object key, Object value)
 	{
 		internalAddRow(index, key, value, "");
 		fireTableRowsInserted(index, index);
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param index int
 	 * @param key Object
 	 * @param value Object
 	 * @param keyInfo String
 	 */
 	public void addRow(int index, Object key, Object value, String keyInfo)
 	{
 		internalAddRow(index, key, value, keyInfo);
 		fireTableRowsInserted(index, index);
 	}
 
 	/**
 	 * Creation date: (3.1.2002 16:34:43)
 	 *
 	 * @param key java.lang.Object
 	 * @param value java.lang.Object
 	 */
 	public void addRow(Object key, Object value)
 	{
 		addRow(keys.size(), key, value);
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param key Object
 	 * @param value Object
 	 * @param keyInfo String
 	 */
 	public void addRow(Object key, Object value, String keyInfo)
 	{
 		addRow(keys.size(), key, value, keyInfo);
 	}
 
 	/**
 	 * Removes all mappings from this map (optional operation).
 	 */
 	public void clear()
 	{
 		keys.clear();
 		values.clear();
 		keyInfo = null;
 		fireTableStructureChanged();
 	}
 
 	/**
 	 * Creation date: (3.1.2002 16:34:43)
 	 *
 	 * @return Object[][]
 	 */
 	public Object[][] getAsArray()
 	{
 		Object[][] u = new Object[keys.size()][2];
 
 		for (int i = 0; i < keys.size(); i++) {
 			u[i][0] = keys.get(i);
 			u[i][1] = values.get(i);
 		}
 
 		return u;
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @return int
 	 *
 	 * @see AbstractTableModel#getColumnCount()
 	 */
 	public int getColumnCount()
 	{
 		if (keyInfo != null) {
 			return 3;
 		}
 
 		return 2;
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param index int
 	 *
 	 * @return String
 	 *
 	 * @see AbstractTableModel#getColumnName(int)
 	 */
 	public String getColumnName(int index)
 	{
 		return columns[colMap[index]].toString();
 	}
 
 	/**
 	 * Creation date: (3.1.2002 16:34:43)
 	 *
 	 * @return java.util.Hashtable
 	 */
 	public java.util.Hashtable getMap()
 	{
 		java.util.Hashtable map = new java.util.Hashtable(keys.size());
 
 		for (int i = 0; i < keys.size(); i++) {
 			Object v = values.get(i);
 			Object k = keys.get(i);
 
 			if (v == null) {
 				v = "";
 			}
 
 			if (k == null) {
 				k = "";
 			}
 
 			map.put(k, v);
 		}
 
 		return map;
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @return int
 	 *
 	 * @see AbstractTableModel#getRowCount()
 	 */
 	public int getRowCount()
 	{
 		return keys.size();
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param row int
 	 * @param column int
 	 *
 	 * @return Object
 	 *
 	 * @see AbstractTableModel#getValueAt(int, int)
 	 */
 	public Object getValueAt(int row, int column)
 	{
 		if ((column == 0) && (keys != null)) {
 			return keys.get(row);
 		} else if ((column == colMap[1]) && (values != null)) {
 			return values.get(row);
 		} else if ((column == colMap[2]) && (keyInfo != null)) {
 			return keyInfo.get(row);
 		} else {
 			return "";
 		}
 	}
 
 	/**
 	 * Creation date: (3.1.2002 16:34:43)
 	 *
 	 * @param index int
 	 * @param keys java.lang.Object
 	 */
 	private void internalAddKeys(int index, Object[] keys)
 	{
 		for (int i = 0; i < keys.length; i++) {
 			internalAddRow(index + i, keys[i], null, "");
 		}
 	}
 
 	/**
 	 * Creation date: (3.1.2002 16:34:43)
 	 *
 	 * @param index int
 	 * @param map java.lang.Object
 	 */
 	private void internalAddMap(int index, Map map)
 	{
 		Object[] newKeys = map.keySet().toArray();
 		Arrays.sort(newKeys, new KeyComparator());
 
 		for (int i = 0; i < newKeys.length; i++) {
 			internalAddRow(index + i, newKeys[i], map.get(newKeys[i]), "");
 		}
 	}
 
 	private void internalAddRow(int index, Object key, Object value,
 	    String keyInfo)
 	{
 		if (this.keyInfo != null) {
 			this.keyInfo.add(keyInfo);
 		}
 
 		keys.add(index, key);
 		values.add(index, value);
 	}
 
 	/**
 	 * Removes all mappings from this map (optional operation).
 	 */
 	private void internalClear()
 	{
 		keys.clear();
 		values.clear();
 		keyInfo = null;
 	}
 
 	/**
 	 * Creation date: (3.1.2002 16:34:43)
 	 *
 	 * @param index int
 	 */
 	private void internalRemoveRow(int index)
 	{
 		keys.remove(index);
 		values.remove(index);
 
 		if (keyInfo != null) {
 			keyInfo.remove(index);
 		}
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param row int
 	 * @param column int
 	 *
 	 * @return boolean
 	 *
 	 * @see AbstractTableModel#isCellEditable(int, int)
 	 */
 	public boolean isCellEditable(int row, int column)
 	{
 		return editable[colMap[column]];
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @return boolean
 	 */
 	public boolean isKeyEditable()
 	{
 		return editable[0];
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @return boolean
 	 */
 	public boolean isValueEditable()
 	{
 		return editable[1];
 	}
 
 	/**
 	 * Creation date: (3.1.2002 16:34:43)
 	 *
 	 * @param index int
 	 */
 	public void removeRow(int index)
 	{
 		internalRemoveRow(index);
 		fireTableRowsDeleted(index, index);
 	}
 
 	/**
 	 * Creation date: (3.1.2002 16:34:43)
 	 *
 	 * @param key java.lang.Object
 	 */
 	public void removeRow(Object key)
 	{
 		int index = keys.indexOf(key);
 		removeRow(index);
 	}
 
 	/**
 	 * Creation date: (3.1.2002 16:34:43)
 	 *
 	 * @param u Object[][]
 	 */
 	public synchronized void setAsArray(Object[][] u)
 	{
 		internalClear();
 
 		for (int i = 0; i < u.length; i++) {
 			internalAddRow(i, u[i][1], u[i][2], "");
 		}
 
 		fireTableDataChanged();
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param name String
 	 *
 	 * @see AbstractTableModel#getColumnName(int)
 	 */
 	public void setKeyColumnName(String name)
 	{
 		synchronized (columns) {
 			columns[0] = name;
 		}
 
 		fireTableStructureChanged();
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param name String
 	 */
 	public void setValueColumnName(String name)
 	{
 		synchronized (columns) {
 			columns[1] = name;
 		}
 
 		fireTableStructureChanged();
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param name String
 	 */
 	public void setKeyInfoColumnName(String name)
 	{
 		columns[2] = name;
 		fireTableStructureChanged();
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param value boolean
 	 */
 	public void setKeyEditable(boolean value)
 	{
 		editable[0] = value;
 	}
 
 	/**
 	 * Creation date: (3.1.2002 16:34:43)
 	 *
 	 * @param keys Object[]
 	 */
 	public synchronized void setKeys(Object[] keys)
 	{
 		this.keys.clear();
 		internalAddKeys(getRowCount(), keys);
 		fireTableDataChanged();
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param map Map
 	 */
 	public synchronized void setMap(Map map)
 	{
 		internalClear();
 		internalAddMap(getRowCount(), map);
 		fireTableDataChanged();
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param value Object
 	 * @param row int
 	 * @param column int
 	 *
 	 * @see AbstractTableModel#setValueAt(int, int)
 	 */
 	public void setValueAt(Object value, int row, int column)
 	{
 		if (column == colMap[0]) {
 			keys.set(row, value);
 		} else if (column == colMap[1]) {
 			values.set(row, value);
 		}
 
 		fireTableCellUpdated(row, column);
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param value boolean
 	 */
 	public void setValueEditable(boolean value)
 	{
 		editable[1] = value;
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @return String
 	 */
 	public String toString()
 	{
 		StringBuffer b = new StringBuffer();
 		b.append(columns[0]);
 		b.append(" - ");
 		b.append(columns[1]);
 
 		for (int i = 0; i < keys.size(); i++) {
 			b.append("\n");
 			b.append(keys.get(i));
 
 			if (keyInfo != null) {
 				b.append(" (");
 				b.append(keyInfo.get(i));
 				b.append(") ");
 			}
 
 			b.append(" - ");
 			b.append(values.get(i));
 		}
 
 		return b.toString();
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param keyInfo String[]
 	 */
 	public synchronized void setKeyInfo(String[] keyInfo)
 	{
 		this.keyInfo = new ArrayList(java.util.Arrays.asList(keyInfo));
 
 		int[] temp = { 0, 2, 1 };
 		colMap = temp;
 		fireTableStructureChanged();
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param values Object[]
 	 *
 	 * @see AbstractTableModel#setValueAt(int, int)
 	 */
 	public void setValues(Object[] values)
 	{
 		this.values.clear();
 		this.values.addAll(java.util.Arrays.asList(values));
 		fireTableDataChanged();
 	}
 
 	/**
 	 * Returns <code>true</code> if contained keys are sorted by their names
 	 * obtained by toString() method.
 	 *
 	 * @return <code>true</code> if contained keys are sorted by their names
 	 *         obtained by toString().
 	 */
 	public boolean isSortByKeyName()
 	{
 		return sortByKeyName;
 	}
 
 	/**
 	 * Set <code>true</code> to force contained keys to be sorted by their
 	 * names obtained by toString() method.
 	 *
 	 * @param b
 	 */
 	public void setSortByKeyName(boolean b)
 	{
 		sortByKeyName = b;
 	}
 
 	/**
 	 * Puts new value under under specified key. If key does not exist, new
 	 * kay-value pair is aded to the end of the table.
 	 *
 	 * @param key the key for which value is to be updated
 	 * @param value new value
 	 *
 	 * @return old value under key or <code>null</code> if no previous value
 	 *         existed
 	 */
 	public Object put(Object key, Object value)
 	{
 		int i = keys.indexOf(key);
 
 		if (i > -1) {
 			Object r = values.get(i);
 			values.set(i, value);
 
 			fireTableCellUpdated(i, colMap[1]);
 
 			return r;
 		}
 
 		addRow(key, value);
 
 		return null;
 	}
 }
 
 /* __oOo__ */