/*
    * 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.table;
  
  import com.cosylab.util.ObjectList;
  
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.Comparator;
  import java.util.Iterator;
  
  
  /**
   * <code>TableRowModelSupport</code> support implementation of
   * <code>TableRowModel</code> based on <code>ArrayList</code>.
   * 
   * <p>
   * <b>Note!</b><br/> This class is not synchronized and is not thread safe.
   * </p>
   *
   * @author <a href="mailto:igor.kriznar@cosylab.com">Igor Kriznar</a>
   * @version $Id: TableRowModelSupport.java,v 1.14 2008-04-22 12:28:40 jbobnar Exp $
   *
   * @since May 4, 2004.
   */
  public class TableRowModelSupport implements TableRowModel
  {
  	// TODO sync on listeners missing
  	private ObjectList listeners = new ObjectList(TableRowModelListener.class);
  	private int columnCount = -1;
  	private ArrayList<TableRow> rows = new ArrayList<TableRow>();
  	private String[] columnNames = null;
  	private Comparator<TableRow> comparator;
  
  	/**
  	 * Creates new instance.
  	 */
  	public TableRowModelSupport()
  	{
  		super();
  	}
  
  	/* (non-Javadoc)
  	 * @see com.cosylab.gui.components.table.TableRowModel#getColumnCount()
  	 */
  	public int getColumnCount()
  	{
  		if (columnCount < 0) {
  			synchronized (rows) {
  				if (rows.size() == 0) {
  					return 0;
  				}
  
  				int c = 0;
  				Iterator it = rows.iterator();
  
  				while (it.hasNext()) {
  					int i = ((TableRow)it.next()).getValueCount();
  
  					if (i > c) {
  						c = i;
  					}
  				}
  
  				return c;
  			}
  		}
  
  		return columnCount;
  	}
  
  	/**
  	 * Sets the number of columns this model presents.
  	 *
  	 * @param count the number of columns
  	 */
  	public void setColumnCount(int count)
  	{
  		columnCount = count;
  	}
  
  	/* (non-Javadoc)
 	 * @see com.cosylab.gui.components.table.TableRowModel#getRowCount()
 	 */
 	public int getRowCount()
 	{
 		return rows.size();
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.components.table.TableRowModel#getRowAt(int)
 	 */
 	public TableRow getRowAt(int rowIndex)
 	{
 		return getRow(rowIndex);
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.components.table.TableRowModel#getRowIndex(com.cosylab.gui.components.table.TableRow)
 	 */
 	public int getRowIndex(TableRow row)
 	{
 		synchronized (rows) {
 			return rows.indexOf(row);
 		}
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.components.table.TableRowModel#addTableRowModelListener(com.cosylab.gui.components.table.TableRowModelListener)
 	 */
 	public void addTableRowModelListener(TableRowModelListener l)
 	{
 		listeners.add(l);
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.components.table.TableRowModel#removeTableRowModelListener(com.cosylab.gui.components.table.TableRowModelListener)
 	 */
 	public void removeTableRowModelListener(TableRowModelListener l)
 	{
 		listeners.remove(l);
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.components.table.TableRowModel#getColumnName(int)
 	 */
 	public String getColumnName(int index)
 	{
 		if (columnNames == null) {
 			return String.valueOf(index);
 		}
 
 		return columnNames[index];
 	}
 
 	/**
 	 * Sets column names.
 	 *
 	 * @param names the column names
 	 */
 	public void setColumnNames(String[] names)
 	{
 		columnNames = names;
 	}
 
 	/**
 	 * Adds row to the end of the row list.
 	 *
 	 * @param row the row to be added
 	 */
 	public void addRow(TableRow row)
 	{
 		row.setParentModel(this);
 
 		boolean structure = false;
 
 		synchronized (rows) {
 			structure = rows.size() == 0;
 			rows.add(row);
 		}
 
 		if (structure) {
 			fireStructureChange(row);
 		} else {
 			fireRowAdded(row, rows.size() - 1);
 		}
 	}
 
 	/**
 	 * Inserts row at the specified index.
 	 *
 	 * @param index the index where to insert
 	 * @param row the row to be added
 	 */
 	public void addRow(int index, TableRow row)
 	{
 		row.setParentModel(this);
 
 		boolean structure = false;
 
 		synchronized (rows) {
 			structure = rows.size() == 0;
 			rows.add(index, row);
 		}
 
 		if (structure) {
 			fireStructureChange(row);
 		} else {
 			fireRowAdded(row, index);
 		}
 	}
 
 	/**
 	 * Returns row at given index,
 	 *
 	 * @param index the index of  the row
 	 *
 	 * @return the row at the specified index
 	 */
 	public TableRow getRow(int index)
 	{
 		synchronized (rows) {
 			if (index > -1 && index < rows.size()) {
 				return (TableRow)rows.get(index);
 			}
 
 			return null;
 		}
 	}
 
 	/**
 	 * Removes row from this model.
 	 *
 	 * @param index rowindex to be roemoved
 	 *
 	 * @return the removed row
 	 */
 	public TableRow removeRow(int index)
 	{
 		TableRow r;
 
 		boolean structure = false;
 
 		synchronized (rows) {
 			r = (TableRow)rows.remove(index);
 			structure = rows.size() == 0;
 		}
 
 		r.setParentModel(null);
 
 		if (structure) {
 			fireStructureChange(r);
 		} else {
 			fireRowRemoved(r, index);
 		}
 
 		return r;
 	}
 
 	/**
 	 * Removes row from this model.
 	 *
 	 * @param row the row to be removed
 	 */
 	public void removeRow(TableRow row)
 	{
 		int i;
 
 		boolean structure = false;
 
 		synchronized (rows) {
 			i = rows.indexOf(row);
 
 			if (i < 0) {
 				return;
 			}
 
 			rows.remove(i);
 			structure = rows.size() == 0;
 		}
 
 		row.setParentModel(null);
 
 		if (structure) {
 			fireStructureChange(row);
 		} else {
 			fireRowRemoved(row, i);
 		}
 	}
 
 	protected void fireChange(TableRowModelEvent event)
 	{
 		TableRowModelListener[] l = (TableRowModelListener[])listeners.toArray();
 
 		for (int i = 0; i < l.length; i++) {
 			try {
 				l[i].tableChanged(event);
 			} catch (Exception e) {
 				e.printStackTrace();
 			}
 		}
 	}
 
 	protected void fireStructureChange(TableRow r)
 	{
 		fireChange(new TableRowModelEvent(r, TableRowModelEvent.HEADER_ROW));
 	}
 
 	protected void fireRowAdded(TableRow row, int index)
 	{
 		fireChange(new TableRowModelEvent(row, index,
 		        TableRowModelEvent.ALL_VALUES, TableRowModelEvent.INSERT));
 	}
 
 	protected void fireRowRemoved(TableRow row, int index)
 	{
 		fireChange(new TableRowModelEvent(row, index,
 		        TableRowModelEvent.ALL_VALUES, TableRowModelEvent.DELETE));
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.components.table.TableRowModel#fireRowUpdate(com.cosylab.gui.components.table.TableRow, int)
 	 */
 	public void fireRowUpdate(TableRow row, int valueIndex)
 	{
 		fireChange(new TableRowModelEvent(row, getRowIndex(row), valueIndex,
 		        TableRowModelEvent.UPDATE));
 	}
 
 	/**
 	 * Removes all rows from this model.
 	 */
 	public void removeAllRows()
 	{
 		if (rows.size() == 0) {
 			return;
 		}
 
 		TableRow[] r;
 
 		synchronized (rows) {
 			r = new TableRow[rows.size()];
 			rows.toArray(r);
 			rows.clear();
 		}
 
 		for (int i = 0; i < r.length; i++) {
 			r[i].setParentModel(null);
 		}
 
 		fireStructureChange(r[0]);
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.components.table.TableRowModel#sortRows(int, boolean)
 	 */
 	public void sortRows(int column, boolean descending)
 	{
 		if (rows.size() == 0) {
 			return;
 		}
 
 		synchronized (rows) {
 			if (comparator == null)
 				Collections.sort(rows, new DefaultRowComparator(column, descending));
 			else
 				if (comparator instanceof RowComparator) {
 					((RowComparator)comparator).setColumn(column);
 					((RowComparator)comparator).setDescending(descending);
 				}
 				Collections.sort(rows, comparator);
 		}
 
 		fireChange(new TableRowModelEvent(getRow(0), -1));
 	}
 
 	/**
 	 * @return the comparator
 	 */
 	public Comparator getComparator() {
 		return comparator;
 	}
 
 	/**
 	 * @param comparator the comparator to set
 	 */
 	public void setComparator(Comparator<TableRow> comparator) {
 		this.comparator = comparator;
 	}
 }
 
 /* __oOo__ */