package net.xoetrope.swing.table;
import java.util.Vector;
import javax.swing.event.TableModelListener;
import javax.swing.table.TableModel;
import net.xoetrope.xui.XProject;
import net.xoetrope.xui.data.XBaseModel;
import net.xoetrope.xui.data.XModel;
import net.xoetrope.xui.helper.XTranslator;
/**
* Create a new table model for use by the XTable class
*/
class XTableModel implements TableModel
{
/**
* The data model
*/
private XModel model;
/**
* the table listeners
*/
private Vector listeners;
/**
* true to display a header
*/
private boolean hasHeaderRow;
private boolean usesDatabase;
private boolean translateable;
private XTranslator translator;
/**
* Create a new table model
* @param currentProject the owner project
* @param newModel the data model source
*/
public XTableModel( XProject currentProject, XModel newModel )
{
model = newModel;
usesDatabase = ( model.getClass().getName().indexOf( "DatabaseTableModel" ) > 0 );
listeners = new Vector();
hasHeaderRow = false;
translateable = false;
translator = currentProject.getTranslator();
}
/**
* Set the translateable state of the model
* @param state 'true' for a transalted table
*/
public void setTranslated( boolean state )
{
translateable = state;
}
/**
* Get the translateable state of the table
* @return true if the table is translateable
*/
public boolean getTranslated()
{
return translateable;
}
/**
* Returns the number of rows in the model. A
* <code>JTable</code> uses this method to determine how many rows it
* should display. This method should be quick, as it
* is called frequently during rendering.
*
* @return the number of rows in the model
* @see #getColumnCount
*/
public int getRowCount()
{
if ( hasHeaderRow )
return model.getNumChildren() -1;
return model.getNumChildren();
}
/**
* Returns the number of columns in the model. A
* <code>JTable</code> uses this method to determine how many columns it
* should create and display by default.
*
* @return the number of columns in the model
* @see #getRowCount
*/
public int getColumnCount()
{
if ( model.getNumChildren() > 0 ) {
if ( usesDatabase )
return model.getNumAttributes();
else if ( model instanceof XBaseModel ) {
XBaseModel row0 = (XBaseModel)((XBaseModel)model).get( 0 );
if ( row0.getTagName().equals( "th" )) {
hasHeaderRow = true;
return row0.getNumChildren();
}
}
}
return model.getNumAttributes();
}
/**
* Returns the name of the column at <code>columnIndex</code>. This is used
* to initialize the table's column header name. Note: this name does
* not need to be unique; two columns in a table can have the same name.
*
* @param columnIndex the index of the column
* @return the name of the column
*/
public String getColumnName(int columnIndex)
{
if ( hasHeaderRow ) {
if ( model instanceof XBaseModel ) {//usesDatabase ) {
XBaseModel row0 = ( XBaseModel ) ( ( XBaseModel ) model ).get( 0 );
return row0.get( columnIndex ).getAttribValueAsString( XBaseModel.VALUE_ATTRIBUTE );
}
}
return model.getAttribName( columnIndex );
}
/**
* Returns the most specific superclass for all the cell values
* in the column. This is used by the <code>JTable</code> to set up a
* default renderer and editor for the column.
*
* @param columnIndex the index of the column
* @return the common ancestor class of the object values in the model.
*/
public Class getColumnClass(int columnIndex)
{
return String.class;
}
/**
* Returns true if the cell at <code>rowIndex</code> and
* <code>columnIndex</code>
* is editable. Otherwise, <code>setValueAt</code> on the cell will not
* change the value of that cell.
*
* @param rowIndex the row whose value to be queried
* @param columnIndex the column whose value to be queried
* @return true if the cell is editable
* @see #setValueAt
*/
public boolean isCellEditable(int rowIndex, int columnIndex)
{
return false;
}
/**
* Returns the value for the cell at <code>columnIndex</code> and
* <code>rowIndex</code>.
*
* @param rowIndex the row whose value is to be queried
* @param columnIndex the column whose value is to be queried
* @return the value Object at the specified cell
*/
public Object getValueAt(int rowIndex, int columnIndex)
{
Object obj = model.get( rowIndex + ( hasHeaderRow ? 1 : 0 )).get( columnIndex ).get();
if (( obj instanceof String ) && translateable )
return translator.translate( (String)obj );
return obj;
}
/**
* Sets the value in the cell at <code>columnIndex</code> and
* <code>rowIndex</code> to <code>aValue</code>.
*
* @param aValue the new value
* @param rowIndex the row whose value is to be changed
* @param columnIndex the column whose value is to be changed
* @see #getValueAt
* @see #isCellEditable
*/
public void setValueAt(Object aValue, int rowIndex, int columnIndex)
{
}
/**
* Adds a listener to the list that is notified each time a change
* to the data model occurs.
*
* @param l the TableModelListener
*/
public void addTableModelListener( TableModelListener l )
{
listeners.add( l );
}
/**
* Removes a listener from the list that is notified each time a
* change to the data model occurs.
*
* @param l the TableModelListener
*/
public void removeTableModelListener( TableModelListener l )
{
listeners.remove( l );
}
}