mtable.java

Java写的ERP系统

		//	Make Rows selectable
		if (col == 0)
			return true;

		//	Entire Table not editable
		if (m_readOnly)
			return false;
		//	Key & ID not editable
		if (col == m_IDColumnIndex || col == m_keyColumnIndex)
			return false;
		/** @todo check link columns */

		//	Check column range
		if (col < 0 && col >= m_fields.size())
			return false;
		//  IsActive Column always editable if no processed exists
		if (col == m_activeColumnIndex && m_processedColumnIndex == -1)
			return true;
		//	Row
		if (!isRowEditable(row))
			return false;

		//	Column
		return ((MField)m_fields.get(col)).isEditable(false);
	}	//	IsCellEditable


	/**
	 *	Is Current Row Editable
	 *  @param row row
	 *  @return true if editable
	 */
	public boolean isRowEditable (int row)
	{
	//	Log.trace(Log.l6_Database, "MTable.isRowEditable");
		//	Entire Table not editable or no row
		if (m_readOnly || row < 0)
			return false;
		//	If not Active - not editable
		if (m_activeColumnIndex > 0 && "N".equals(getValueAt(row, m_activeColumnIndex))) // && m_TabNo != Find.s_TabNo)
			return false;
		//	If Processed - not editable (Find always editable)
		if (m_processedColumnIndex > 0 && "Y".equals(getValueAt(row, m_processedColumnIndex)))   // && m_TabNo != Find.s_TabNo)
			return false;

		return true;
	}	//	isRowEditable

	/**
	 *	Set entire table as read only
	 *  @param value new read only value
	 */
	public void setReadOnly (boolean value)
	{
		Log.trace(Log.l4_Data, "MTable.setReadOnly " + value);
		m_readOnly = value;
	}	//	setReadOnly

	/**
	 *  Is Read/Only
	 *  @return true if read only
	 */
	public boolean isReadOnly()
	{
		return m_readOnly;
	}   //  isReadOnly

	/**
	 *  Is inserting
	 *  @return true if inserting
	 */
	public boolean isInserting()
	{
		return m_inserting;
	}   //  isInserting

	/**
	 *	Can Table rows be deleted
	 *  @param value new deleteable value
	 */
	public void setDeleteable (boolean value)
	{
		Log.trace(Log.l4_Data, "MTable.setDeleteable " + value);
		m_deleteable = value;
	}	//	setDeleteable

	/*************************************************************************/

	/**
	 *	Read Data from Recordset
	 *  @param rs result set
	 *  @return Data Array
	 */
	private Object[] readData (ResultSet rs)
	{
		int size = m_fields.size();
		Object[] rowData = new Object[size];
		String columnName = null;
		int displayType = 0;

		try
		{
			//	get row data
			for (int j = 0; j < size; j++)
			{
				//	Column Info
				MField field = (MField)m_fields.get(j);
				columnName = field.getColumnName();
				displayType = field.getDisplayType();
				//	Number
				if (DisplayType.isNumeric(displayType))
					rowData[j] = rs.getBigDecimal(j+1);			//	BigDecimal
				//	ID, Lookup (UpdatedBy is a numeric column)
				else if (DisplayType.isID(displayType) && (columnName.endsWith("_ID")) || columnName.endsWith("edBy"))
				{
					rowData[j] = new Integer(rs.getInt(j+1));	//	Integer
					if (rs.wasNull())
						rowData[j] = null;
				}
				//	Date
				else if (DisplayType.isDate(displayType))
					rowData[j] = rs.getTimestamp(j+1);			//	Timestamp
				//	RowID or Key (and Selection)
				else if (displayType == DisplayType.RowID)
				{
					Object[] rid = new Object[3];
					if (columnName.equals("ROWID"))
						rid[0] = DB.getDatabase().getRowID(rs, j+1);
					else
						rid[2] = new Integer (rs.getInt(j+1));
					rid[1] = new Boolean(false);
					rowData[j] = rid;
				}
				//	String
				else
					rowData[j] = rs.getString(j+1);				//	String
			}
		}
		catch (SQLException e)
		{
			Log.error("MTable.readData - " + columnName + ", DT=" + displayType, e);
		}
		return rowData;
	}	//	readData

	/*************************************************************************/

	/**
	 *	Remove Data Status Listener
	 *  @param l listener
	 */
	public synchronized void removeDataStatusListener(DataStatusListener l)
	{
		if (m_dataStatusListeners != null && m_dataStatusListeners.contains(l))
		{
			Vector v = (Vector) m_dataStatusListeners.clone();
			v.removeElement(l);
			m_dataStatusListeners = v;
		}
	}	//	removeDataStatusListener

	/**
	 *	Add Data Status Listener
	 *  @param l listener
	 */
	public synchronized void addDataStatusListener(DataStatusListener l)
	{
		Vector v = m_dataStatusListeners == null ? new Vector(2) : (Vector) m_dataStatusListeners.clone();
		if (!v.contains(l))
		{
			v.addElement(l);
			m_dataStatusListeners = v;
		}
	}	//	addDataStatusListener

	/**
	 *	Inform Listeners
	 *  @param e event
	 */
	private void fireDataStatusChanged (DataStatusEvent e)
	{
		if (m_dataStatusListeners != null)
		{
			Vector listeners = m_dataStatusListeners;
			int count = listeners.size();
			for (int i = 0; i < count; i++)
				((DataStatusListener) listeners.elementAt(i)).dataStatusChanged(e);
		}
	}	//	fireDataStatusChanged

	/**
	 *  Create Data Status Event
	 *  @return data status event
	 */
	private DataStatusEvent createDSE()
	{
		boolean changed = m_changed;
		if (m_rowChanged != -1)
			changed = true;
		DataStatusEvent dse = new DataStatusEvent(this, m_rowCount, changed,
			Env.isAutoCommit(m_ctx, m_WindowNo), m_inserting);
		return dse;
	}   //  createDSE

	/**
	 *  Create and fire Data Status Info Event
	 *  @param AD_Message message
	 */
	protected void fireDataStatusIEvent (String AD_Message)
	{
		DataStatusEvent e = createDSE();
		e.setInfo(AD_Message, "", false);
		fireDataStatusChanged (e);
	}   //  fireDataStatusEvent

	/**
	 *  Create and fire Data Status Error Event
	 *  @param AD_Message message
	 *  @param info info
	 */
	protected void fireDataStatusEEvent (String AD_Message, String info)
	{
		DataStatusEvent e = createDSE();
		e.setInfo(AD_Message, info, true);
		Log.saveError(AD_Message, info);
		fireDataStatusChanged (e);
	}   //  fireDataStatusEvent

	/**
	 *  Create and fire Data Status Event (from Error Log)
	 *  @param errorLog error log info
	 */
	protected void fireDataStatusEEvent (ValueNamePair errorLog)
	{
		if (errorLog != null)
			fireDataStatusEEvent (errorLog.getValue(), errorLog.getName());
	}   //  fireDataStatusEvent

	/*************************************************************************/

	/**
	 * Adds a listener to the list that's notified each time a change
	 * to the data model occurs.
	 * @param	l		the TableModelListener
	 */
	public void addTableModelListener (TableModelListener l)
	{
		m_tableModelListeners.add (TableModelListener.class, l);
	}   //  addTableModelListener

	/**
	 * Removes a listener from the list that's notified each time a
	 * change to the data model occurs.
	 * @param	l		the TableModelListener
	 */
	public void removeTableModelListener (TableModelListener l)
	{
		m_tableModelListeners.remove (TableModelListener.class, l);
	}   //  removeTableModelListener

	/**
	 * Notifies all listeners that all cell values in the table's
	 * rows may have changed. The number of rows may also have changed
	 * and the <code>JTable</code> should redraw the
	 * table from scratch. The structure of the table (as in the order of the
	 * columns) is assumed to be the same.
	 *
	 * @see TableModelEvent
	 * @see EventListenerList
	 */
	public void fireTableDataChanged()
	{
		fireTableChanged (new TableModelEvent(this));
	}   //  fireTableDataChanged

	/**
	 * Notifies all listeners that the table's structure has changed.
	 * The number of columns in the table, and the names and types of
	 * the new columns may be different from the previous state.
	 * If the <code>JTable</code> receives this event and its
	 * <code>autoCreateColumnsFromModel</code>
	 * flag is set it discards any table columns that it had and reallocates
	 * default columns in the order they appear in the model. This is the
	 * same as calling <code>setModel(TableModel)</code> on the
	 * <code>JTable</code>.
	 *
	 * @see TableModelEvent
	 * @see EventListenerList
	 */
	public void fireTableStructureChanged()
	{
		fireTableChanged (new TableModelEvent(this, TableModelEvent.HEADER_ROW));
	}   //  fireTableStructureChanged

	/**
	 * Notifies all listeners that rows in the range
	 * <code>[firstRow, lastRow]</code>, inclusive, have been inserted.
	 *
	 * @param  firstRow  the first row
	 * @param  lastRow   the last row
	 *
	 * @see TableModelEvent
	 * @see EventListenerList
	 */
	public void fireTableRowsInserted (int firstRow, int lastRow)
	{
		fireTableChanged (new TableModelEvent(this, firstRow, lastRow,
								TableModelEvent.ALL_COLUMNS, TableModelEvent.INSERT));
	}   //  fireTableRowsInserted

	/**
	 * Notifies all listeners that rows in the range
	 * <code>[firstRow, lastRow]</code>, inclusive, have been updated.
	 *
	 * @param firstRow  the first row
	 * @param lastRow   the last row
	 *
	 * @see TableModelEvent
	 * @see EventListenerList
	 */
	public void fireTableRowsUpdated(int firstRow, int lastRow)
	{
		fireTableChanged(new TableModelEvent(this, firstRow, lastRow,
								TableModelEvent.ALL_COLUMNS, TableModelEvent.UPDATE));
	}   //  fireTableRowsUpdated

	/**
	 * Notifies all listeners that rows in the range
	 * <code>[firstRow, lastRow]</code>, inclusive, have been deleted.
	 *
	 * @param firstRow  the first row
	 * @param lastRow   the last row
	 *
	 * @see TableModelEvent
	 * @see EventListenerList
	 */
	public void fireTableRowsDeleted(int firstRow, int lastRow)
	{
		fireTableChanged(new TableModelEvent(this, firstRow, lastRow,
								TableModelEvent.ALL_COLUMNS, TableModelEvent.DELETE));
	}   //  fireTableRowsDeleted

	/**
	 * Notifies all listeners that the value of the cell at
	 * <code>[row, column]</code> has been updated.
	 *
	 * @param row  row of cell which has been updated
	 * @param column  column of cell which has been updated
	 * @see TableModelEvent
	 * @see EventListenerList
	 */
	public void fireTableCellUpdated(int row, int column)
	{
		fireTableChanged(new TableModelEvent(this, row, row, column));
	}   //  fireTableCellUpdated

	/**
	 * Forwards the given notification event to all
	 * <code>TableModelListeners</code> that registered
	 * themselves as listeners for this table model.
	 *
	 * @param e  the event to be forwarded
	 *
	 * @see #addTableModelListener
	 * @see TableModelEvent
	 * @see EventListenerList
	 */
	public void fireTableChanged(TableModelEvent e)
	{
		// Guaranteed to return a non-null array
		Object[] listeners = m_tableModelListeners.getListenerList();
		// Process the listeners last to first, notifying
		// those that are interested in this event
		for (int i = listeners.length-2; i>=0; i-=2)
		{
			if (listeners[i]==TableModelListener.class)
			{
				((TableModelListener)listeners[i+1]).tableChanged(e);
			}
		}
	}   //  fireTableChanged

	/**
	 * Returns an array of all the listeners of the given type that
	 * were added to this model.
	 *
	 * @returns all of the objects receiving <code>listenerType</code>
	 *		notifications from this model
	 * @since 1.3
	 *
	public EventListener[] getListeners(Class listenerType)
	{
		return m_tableModelListeners.getListeners(listenerType);
	}   //  getListeners

	/*************************************************************************/

	/**
	 *  Remove Vetoable change listener for row changes
	 *  @param l listener
	 */
	public synchronized void removeVetoableChangeListener(VetoableChangeListener l)
	{
		m_vetoableChangeSupport.removeVetoableChangeListener(l);
	}   //  removeVetoableChangeListener

	/**
	 *  Add Vetoable change listener for row changes
	 *  @param l listener
	 */
	public synchronized void addVetoableChangeListener(VetoableChangeListener l)
	{
		m_vetoableChangeSupport.addVetoableChangeListener(l);
	}   //  addVetoableChangeListener

	/**
	 *  Fire Vetoable change listener for row changes
	 *  @param e event
	 *  @throws PropertyVetoException
	 */
	protected void fireVetoableChange(PropertyChangeEvent e) throws java.beans.PropertyVetoException
	{
		m_vetoableChangeSupport.fireVetoableChange(e);
	}   //  fireVetoableChange

	/**
	 *  toString
	 *  @return String representation
	 */
	public String toString()
	{
		return new StringBuffer("MTable[").append(m_tableName)
			.append(",WindowNo=").append(m_WindowNo)
			.append(",Tab=").append(m_TabNo).append("]").toString();
	}   //  toString


	/*************************************************************************/

	/**
	 *	ASync Loader
	 */
	class Loader extends Thread implements Serializable
	{
		/**
		 *  Construct Loader
		 */
		public Loader()
		{
			super("TLoader");
		}	//	Loader

		private PreparedStatement   m_pstmt = null;
		private ResultSet 		    m_rs = null;

		/**
		 *	Open ResultSet
		 *	@return number of records
		 */
		private int open()
		{
		//	Log.trace(Log.l4_Data, "MTable Loader.open");
			//	Get Number of Rows
			int rows = 0;
			try
			{
				PreparedStatement pstmt = DB.prepareStatement(m_SQL_Count);
				setParameter (pstmt, true);
				ResultSet rs = pstmt.executeQuery();
				if (rs.next())
					rows = rs.getInt(1);
				rs.close();
				pstmt.close();
			}
			catch (SQLException e0)
			{
				Log.err