package org.swingml.tablebrowser.ext;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import java.util.List;
import javax.swing.*;
import javax.swing.event.*;
import javax.swing.table.*;
import javax.swing.text.*;
import org.swingml.*;
import org.swingml.action.*;
import org.swingml.component.*;
import org.swingml.component.ext.*;
import org.swingml.errors.*;
import org.swingml.event.*;
import org.swingml.model.*;
import org.swingml.registry.*;
import org.swingml.system.*;
import org.swingml.tablebrowser.rowheader.*;
public class TableBrowserComponent extends JTable implements XMLTranslatable, MouseListener, ListSelectionListener, SelectionMadeRemoteActionSubject, XMLStateTranslatable {
private class TableBrowserCellData {
private int column;
private int row;
private boolean selected;
public TableBrowserCellData (int aRow, int aColumn) {
setRow(aRow);
setColumn(aColumn);
}
public TableBrowserCellData (int aRow, int aColumn, boolean isSelected) {
this(aRow, aColumn);
setSelected(isSelected);
}
public int getColumn () {
return column;
}
public int getRow () {
return row;
}
private boolean isRowDirty () {
boolean result = false;
// check entire row
for (int x = 0; x < getColumnCount(); x++) {
CellDataValue cell = (CellDataValue) getValueAt(getRow(), x);
if (cell.isDirty()) {
result = true;
break;
}
}
return result;
}
public boolean isSelected () {
return selected;
}
public void setColumn (int aColumn) {
this.column = aColumn;
}
public void setRow (int aRow) {
this.row = aRow;
}
public void setSelected (boolean isSelected) {
this.selected = isSelected;
}
/**
* Check validity of row/column numbers, as well as the onlypostdirty flags/values
*/
public boolean shouldBeExported () {
boolean result = false;
if (getRow() != -1 && getColumn() != -1) {
// check dirty flags
if (m_tableModel.isOnlyPostDirty()) {
CellDataValue value = (CellDataValue) getValueAt(getRow(), getColumn());
switch (m_tableModel.getSelectionStyle()) {
case TableBrowserModel.SELECTION_STYLE_SINGLE_CELL:
result = value.isDirty();
break;
case TableBrowserModel.SELECTION_STYLE_MULTI_CELL:
result = value.isDirty();
break;
case TableBrowserModel.SELECTION_STYLE_SINGLE_ROW:
// check entire row
result = isRowDirty();
break;
case TableBrowserModel.SELECTION_STYLE_MULTI_ROW:
// check entire row
result = isRowDirty();
break;
case TableBrowserModel.SELECTION_STYLE_DEFAULT:
result = true;
break;
}
} else {
// don't care about dirty flag
result = true;
}
}
return result;
}
}
private TableBrowser browser = null;
private ITableBrowserCellNavigationManager cellManager;
private EventHandler eventHandler = EventHandler.getInstance();
private boolean filtering;
private boolean handlingEditingStopped;
private int[] internalSelectedRows;
private TableBrowserModel m_tableModel = null;
private boolean movingRows;
private boolean painting;
private RowHeaderTable rowHeaderTable = null;
private TableSort sort = null;
public TableBrowserComponent (TableBrowserModel aModel) {
// create contract, mediate data access
TableBrowserContract tbc = new TableBrowserContract(aModel.data());
tbc.setHeadings(aModel.extractColumnNames());
// create and assign browser, browser handles sorting and filtering
setBrowser(new TableBrowser(tbc, this, aModel));
aModel.setTableBrowser(getBrowser());
aModel.setContainer(this);
this.m_tableModel = aModel;
super.setName(aModel.getName());
super.setToolTipText(aModel.getTooltip());
super.addMouseListener(this);
if (aModel.getWidth() > 0 || aModel.getHeight() > 0) {
Dimension size = new Dimension(aModel.getWidth(), aModel.getHeight());
super.setSize(size);
}
super.getSelectionModel().setSelectionMode(aModel.getMode());
ToolTipManager.sharedInstance().registerComponent(this);
switch (aModel.getSelectionStyle()) {
case TableBrowserModel.SELECTION_STYLE_SINGLE_CELL:
setColumnSelectionAllowed(true);
setRowSelectionAllowed(true);
setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
break;
case TableBrowserModel.SELECTION_STYLE_MULTI_CELL:
setColumnSelectionAllowed(true);
setRowSelectionAllowed(true);
setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
break;
case TableBrowserModel.SELECTION_STYLE_MULTI_ROW:
setColumnSelectionAllowed(false);
setRowSelectionAllowed(true);
setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
break;
default:
// Default is single-row-selection style
setColumnSelectionAllowed(false);
setRowSelectionAllowed(true);
setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
break;
}
setSort(new TableSort());
getSort().setModel(aModel);
super.setAutoscrolls(true);
}
public void applylCellManager (ITableBrowserCellNavigationManager manager) {
if (manager != null) {
// bind keystrokes for this manager
InputMap inputs = getInputMap(WHEN_FOCUSED);
KeyStroke[] keyStrokes = manager.getKeyStrokes();
for (int x = 0; x < keyStrokes.length; x++) {
KeyStroke keyStroke = keyStrokes[x];
inputs.put(keyStroke, "customKeyStrokeHandler");
}
// Set up the custom action to forward the keystrokes to the manager
AbstractAction myAction = new AbstractAction() {
public void actionPerformed (ActionEvent e) {
if (e.getSource() instanceof TableBrowserComponent) {
if (hasCellManager()) {
getCellManager().handleCellNavigation(getSelectedRow(), getSelectedColumn());
}
}
}
};
getActionMap().put("customKeyStrokeHandler", myAction);
manager.setTableBrowser(this);
}
cellManager = manager;
}
public int convertRowIndexToModel (int rowIndex) {
int result = ((CellDataValue) getValueAt(rowIndex, 0)).getModelRow();
return result;
}
public boolean editCellAt (int row, int column) {
boolean result = false;
if (hasCellManager() && getCellManager().handleCellEditStart(row, column)) {
result = super.editCellAt(row, column);
} else {
// no cell editor manager to worry about
result = super.editCellAt(row, column);
}
return result;
}
public boolean editCellAt (int row, int column, EventObject e) {
boolean result = false;
if (hasCellManager() && getCellManager().handleCellEditStart(row, column)) {
result = super.editCellAt(row, column, e);
} else {
// no cell editor manager to worry about
result = super.editCellAt(row, column, e);
}
return result;
}
public void editingStopped (ChangeEvent e) {
if (!handlingEditingStopped) {
try {
handlingEditingStopped = true;
if (e.getSource() != null && e.getSource() instanceof TableCellEditor) {
TableCellEditor editor = getCellEditor();
Object value = editor.getCellEditorValue();
setValueAt(value, editingRow, editingColumn);
((CellDataValue) getValueAt(editingRow, editingColumn)).setDirty(true);
int theEditingRow = getEditingRow();
int theEditingColumn = getEditingColumn();
removeEditor();
if (hasCellManager()) {
getCellManager().handleCellEditEnd(theEditingRow, theEditingColumn);
}
}
} finally {
handlingEditingStopped = false;
}
}
}
public void filterColumn (String colname, String targetName) {
filterColumn(colname, targetName, true);
}
public void filterColumn (String colname, String targetName, boolean partial) {
while (isCurrentlyPainting() || isFiltering()) {
}
try {
setFiltering(true);
String filter = null;
// get filter from specificed component is prefized with @
if (targetName.indexOf("@") == 0) {
String cleanTarget = targetName.substring(1);
ISwingMLTextContainer theComponent = (ISwingMLTextContainer) eventHandler.findActionTarget(this.getTopLevelAncestor(), cleanTarget);
filter = theComponent.getText();
if (filter != null) {
filter = filter.trim();
}
} else {
filter = targetName;
}
// clear filter if empty
if (filter.trim().equals("")) {
getBrowser().removeFilter(colname);
getBrowser().refreshFilters();
} else {
getBrowser().filterColumn(colname, filter, partial);
}
} catch (Throwable t) {
} finally {
setFiltering(false);
}
}
public void filterColumnStartsWith (String colname, String targetName) {
filterColumn(colname, targetName, false);
}
private void fireInvalidRowNumberError () {
ISwingMLError error = new SwingMLError("Please enter a valid row number (1-" + getRowCount() + ").", ISwingMLError.ERROR_BUSINESS_LOGIC);
ISwingMLError errors[] = new ISwingMLError[1];
errors[0] = error;
((SwingMLModel) getModel()).handle(errors);
}
public TableBrowser getBrowser () {
return this.browser;
}
public TableCellEditor getCellEditor (int row, int column) {
TableCellEditor result = null;
Class clazz = getColumnClass(column);
if (clazz == JButton.class) {
result = new IconComponentCellEditor();
} else {
result = super.getCellEditor(row, column);
}
return result;
}
public ITableBrowserCellNavigationManager getCellManager () {
return cellManager;
}
public int getColumnIndex (String columnName) {
return getColumnModel().getColumnIndex(columnName);
}
private String getColumnStateXML (TableBrowserModel theModel) {
StringBuffer result = new StringBuffer();
if (theModel.isPostColumnState()) {
List columns = theModel.getColumns();
for (int columnIndex = 0; columnIndex < columns.size(); columnIndex++) {
TableBrowserColumnModel theColumn = (TableBrowserColumnModel) columns.get(columnIndex);
result.append("<COLUMN ");
result.append(Constants.TEXT);
result.append("=\"");
result.append(theColumn.getText());
result.append("\" ");
result.append(Constants.WIDTH);
result.append("=\"");
result.append(getColumn(theColumn.getText()).getWidth());
result.append("\" ");
result.append(Constants.VISIBLE);
result.append("=\"");
result.append(theColumn.isVisible());
result.append("\" ");
result.append(Constants.COLUMN_ORDER);
result.append("=\"");
result.append(convertColumnIndexToView(columnIndex));
result.append("\" ");
result.append(Constants.SORT);
result.append("=\"");
String sortType = "ASC";
ColumnHeadingCellRenderer chcr = (ColumnHeadingCellRenderer) getColumn(theColumn.getText()).getHeaderRenderer();
if (chcr.getSortType() != null && chcr.getSortType().equalsIgnoreCase("D")) {
sortType = "DESC";
}
result.append(sortType);
result.append("\" ");
result.append(Constants.SORTORDER);
result.append("=\"");
result.append(chcr.getSort());
result.append("\" />");
}
}
return result.toString();
}
private String getColumnXML (TableBrowserCellData cell) {
String result = "";
TableBrowserModel model = (TableBrowserModel) getModel();
TableBrowserColumnModel tbcm = (TableBrowserColumnModel) model.getColumns().get(cell.getColumn());
CellDataValue cdata = (CellDataValue) model.getValueAt(cell.getRow(), cell.getColumn());
// Column Start
boolean wasClicked = false;
int selectedColumn = getSelectedColumn();
if (selectedColumn == cell.getColumn()) {
wasClicked = true;
}
result += xmlColStart(cdata, tbcm.getText(), wasClicked);
// Value
result += cdata.toString();
// Column end
result += xmlColEnd();
return result;
}
protected int[] getInternalSelectedRows () {
return internalSelectedRows;
}
private String getRowEndXML () {
return "</TBR>";
}
public RowHeaderTable getRowHeaderTable () {
return rowHeaderTable;
}
private String getRowStartXML (TableBrowserCellData cell) {
return "<TBR index=\"" + cell.getRow() + "\" selected=\"" + isRowSelected(cell.getRow()) + "\" >";
}
public TableSort getSort () {
return sort;
}
private String getTableEndXML () {
return "</TABLEBROWSER>";
}
private String getTableStartXML () {
return "<TABLEBROWSER NAME=\"" + super.getName() + "\">";
}
public String getToolTipText (MouseEvent e) {
String aTip = null;
java.awt.Point p = e.getPoint();
int rowIndex = rowAtPoint(p);
int colIndex = columnAtPoint(p);
int realColumnIndex = convertColumnIndexToModel(colIndex);
TableBrowserModel model = (TableBrowserModel) getModel();
try {
aTip = model.getToolTip(convertRowIndexToModel(rowIndex), realColumnIndex);
} catch (ArrayIndexOutOfBoundsException exception) {
aTip = null;
}
if (aTip == null) {
aTip = getToolTipText();
}
return aTip;
}
public String getXMLState () {
StringBuffer result = new StringBuffer();
TableBrowserModel theTableModel = (TableBrowserModel) super.getModel();
boolean postState = theTableModel.isPostColumnState();
theTableModel.setPostColumnState(true);
result.append(getTableStartXML());
result.append(getColumnStateXML(theTableModel));
result.append(getTableEndXML());
theTableModel.setPostColumnState(postState);
return result.toString();
}
/**
* Using the selectionStyle, find the selected rows/columns and export their
* data
*/
public String getXMLValue () {
if (this.isEditing()) {
this.getCellEditor().stopCellEditing();
}
List cellsToExport = new ArrayList();
TableBrowserModel theTableModel = null;
Object theModel = super.getModel();
String thePostStyle = Constants.POST_ALL;
if (theModel instanceof JTableModel) {
theTableModel = (TableBrowserModel) theModel;
thePostStyle = theTableModel.getPostStyle();
}
int[] columnsToPost = theTableModel.getPostColumns();
if (columnsToPost == null || columnsToPost.length == 0) {
// Post all columns, since they didn't specify
columnsToPost = new int[getColumnCount()];
for (int x = 0; x < getColumnCount(); x++) {
columnsToPost[x] = x;
}
}
StringBuffer result = new StringBuffer();
if (thePostStyle.equalsIgnoreCase(Constants.POST_ALL)) {
// Export all rows/columns
for (int row = 0; row < getRowCount(); row++) {
for (int column = 0; column < columnsToPost.length; column++) {
TableBrowserCellData cell = new TableBrowserCellData(row, columnsToPost[column]);
if (isCellSelected(row, columnsToPost[column])) {
cell.setSelected(true);
}
cellsToExport.add(cell);
}
}
} else {
// Only export selected rows/columns
switch (m_tableModel.getSelectionStyle()) {
case TableBrowserModel.SELECTION_STYLE_SINGLE_CELL:
// Single selected cell
cellsToExport.add(new TableBrowserCellData(getSelectedRow(), getSelectedColumn(), true));
break;
case TableBrowserModel.SELECTION_STYLE_MULTI_CELL:
// Multiple selected cells
int[] selectedColumns = getSelectedColumns();
int[] selectedRows = getSelectedRows();
for (int x = 0; x < selectedRows.length; x++) {
for (int y = 0; y < selectedColumns.length; y++) {
if (isCellSelected(selectedRows[x], selectedColumns[y])) {
cellsToExport.add(new TableBrowserCellData(selectedRows[x], selectedColumns[y], true));
}
}
}
break;
case TableBrowserModel.SELECTION_STYLE_MULTI_ROW:
// Mutliple selected rows - use Post columns for all
// selected rows
selectedRows = getSelectedRows();
for (int x = 0; x < selectedRows.length; x++) {
for (int y = 0; y < columnsToPost.length; y++) {
boolean columnWasSelected = getSelectedColumn() == columnsToPost[y];
cellsToExport.add(new TableBrowserCellData(selectedRows[x], columnsToPost[y], columnWasSelected));
}
}
break;
default:
// Single selected row - use Post column for the one row
int selectedRow = getSelectedRow();
if (selectedRow != -1) {
for (int x = 0; x < columnsToPost.length; x++) {
boolean columnWasSelected = getSelectedColumn() == columnsToPost[x];
cellsToExport.add(new TableBrowserCellData(selectedRow, columnsToPost[x], columnWasSelected));
}
}
break;
}
}
// Export the data now
result.append(getTableStartXML());
if (cellsToExport != null && cellsToExport.size() > 0) {
TableBrowserCellData cell;
int currentRow = -1;
boolean exportedACell = false;
Iterator schmiterator = cellsToExport.iterator();
while (schmiterator.hasNext()) {
cell = (TableBrowserCellData) schmiterator.next();
if (cell.shouldBeExported()) {
exportedACell = true;
if (cell.getRow() != currentRow) {
// is this the first row ever?
if (currentRow != -1) {
result.append(getRowEndXML());
}
// start a new row
result.append(getRowStartXML(cell));
currentRow = cell.getRow();
}
result.append(getColumnXML(cell));
}
}
if (exportedACell) {
result.append(getRowEndXML());
}
result.append(getColumnStateXML(theTableModel));
}
result.append(getTableEndXML());
return result.toString();
}
private boolean hasCellManager () {
return getCellManager() != null;
}
public boolean hasState () {
return true;
}
private List incrementIntegerNumbers (List integerList, int increment) {
List result = null;
if (integerList != null) {
result = new ArrayList();
Iterator schmiterator = integerList.iterator();
while (schmiterator.hasNext()) {
int newValue = ((Integer) schmiterator.next()).intValue() + increment;
result.add(new Integer(newValue));
}
}
return result;
}
/*
* (non-Javadoc)
*
* @see org.swingml.action.SelectionMadeRemoteActionSubject#invoke(org.swingml.action.SelectionMadeResult)
*/
public void invoke (SelectionMadeResult result) {
SwingMLLogger.getInstance().log("Inovking Selection Action " + result);
ActionModel model = new ActionModel();
model.setComponent(result.getComponent());
model.setMethod(result.getMethod());
model.setTypes(result.getType());
model.setValues(result.getValue());
// invoke method
EventUtil util = new EventUtil();
Component comp = util.getComponent(this, model.getComponent());
if (comp == null) {
throw new RuntimeException("Select Result Component (" + model.getComponent() + ") not found, check spelling.. ");
}
EventHandler.getInstance().processAction(model, comp, model.getComponent(), null);
}
protected boolean isCurrentlyPainting () {
return painting;
}
public boolean isFiltering () {
return filtering;
}
public boolean isMovingRows () {
return movingRows;
}
/**
* @see java.awt.event.MouseListener#mouseClicked(MouseEvent)
*/
public void mouseClicked (MouseEvent aEvt) {
final int DOUBLE_CLICK_COUNT = 2;
final int SINGLE_CLICK_COUNT = 1;
String theEventType = null;
switch (aEvt.getClickCount()) {
case DOUBLE_CLICK_COUNT:
theEventType = Constants.MOUSE_DOUBLE_CLICKED;
break;
case SINGLE_CLICK_COUNT:
theEventType = Constants.MOUSE_SINGLE_CLICKED;
break;
default:
theEventType = null;
break;
}
if (theEventType != null && theEventType.length() > 0) {
SwingMLModel modelToNotify = (SwingMLModel) super.getModel(); // default to notifying the table
// look for cell or row listeners first
TableBrowserModel model = (TableBrowserModel) getModel();
if (getSelectedRow() >= 0) {
TableRowModel rowModel = (TableRowModel) model.getRows().get(getSelectedRow());
if (rowModel != null) {
TableDataModel aDataModel = (TableDataModel) rowModel.getChildren().get(getSelectedColumn());
if (aDataModel != null && aDataModel.hasListenersFor(theEventType)) {
// notify cell listener
modelToNotify = aDataModel;
} else if (rowModel.hasListenersFor(theEventType)) {
// notify row listener
modelToNotify = rowModel;
}
}
}
this.eventHandler.handleEvent(modelToNotify, theEventType, this);
}
}
public void mouseEntered (MouseEvent aEvt) {}
public void mouseExited (MouseEvent aEvt) {}
public void mousePressed (MouseEvent aEvt) {}
public void mouseReleased (MouseEvent aEvt) {}
public void moveRowsDown () {
int[] selectedRows = getSelectedRows();
if (selectedRows != null && selectedRows.length > 0) {
setMovingRows(true);
try {
List rowsToSelect = new Vector();
boolean moveLastRowToTop = false;
for (int x = selectedRows.length - 1; x >= 0; x--) {
int rowToMove = selectedRows[x];
if (rowToMove != getRowCount() - 1) {
int newRowNumber = getBrowser().moveRowDown(rowToMove);
rowsToSelect.add(new Integer(newRowNumber));
} else {
// trying to move the last row
// skip consecutive rows, then flag to move last row to top
moveLastRowToTop = true;
int nextRowToProcess = x - 1;
int nextConsecutiveRowNumber = rowToMove;
while (nextRowToProcess >= 0 && selectedRows[nextRowToProcess] == nextConsecutiveRowNumber - 1) {
rowsToSelect.add(new Integer(selectedRows[nextRowToProcess]));
if (nextRowToProcess == 0) {
break;
} else {
nextConsecutiveRowNumber = selectedRows[nextRowToProcess];
nextRowToProcess--;
}
}
x = nextRowToProcess + 1; // add 1 so for-loop doesn't stop
}
}
if (moveLastRowToTop) {
// move last row to top
getBrowser().moveRow(getRowCount() - 1, 0);
// increment all the numbers by one, since the last row gets moved to top and all rows move down one
rowsToSelect = incrementIntegerNumbers(rowsToSelect, 1);
// add first row to be selected
rowsToSelect.add(new Integer(0));
}
refresh();
reselectRows(rowsToSelect);
} finally {
setMovingRows(false);
}
}
}
/**
* Move the selected rows to the given index
*/
public void moveRowsTo (int index) {
int[] selectedRows = getSelectedRows();
if (selectedRows != null && selectedRows.length > 0) {
if (index > 0 && index <= getRowCount()) {
setMovingRows(true);
try {
getBrowser().moveRowsTo(selectedRows, index - 1);
// which rows to select now?
List movedRows = new ArrayList();
int start = index - 1;
int end = start + selectedRows.length - 1;
if (index + selectedRows.length > getRowCount()) {
// just select the last rows
end = getRowCount() - 1;
start = end - selectedRows.length + 1;
}
for (int x = start; x <= end; x++) {
movedRows.add(new Integer(x));
}
refresh();
reselectRows(movedRows);
} finally {
setMovingRows(false);
}
} else {
fireInvalidRowNumberError();
}
}
}
public void moveRowsTo (String containerName) {
String newContainerName = containerName;
if (newContainerName.startsWith("@")) {
newContainerName = newContainerName.substring(1);
}
Container container = SwingMLModelToContainerRegistry.getContainer(newContainerName);
if (container != null) {
String value = null;
// add more container types here
if (container instanceof JTextComponent) {
value = ((JTextComponent) container).getText();
}
if (value != null) {
try {
int newRow = Integer.parseInt(value.trim());
moveRowsTo(newRow);
} catch (Exception e) {
fireInvalidRowNumberError();
}
}
}
}
public void moveRowsUp () {
int[] selectedRows = getSelectedRows();
if (selectedRows != null && selectedRows.length > 0) {
setMovingRows(true);
try {
List rowsToSelect = new Vector();
boolean moveFirstRowToBottom = false;
for (int x = 0; x < selectedRows.length; x++) {
int rowToMove = selectedRows[x];
if (rowToMove != 0) {
int newRowNumber = getBrowser().moveRowUp(rowToMove);
rowsToSelect.add(new Integer(newRowNumber));
} else {
// trying to move the first row
// skip consecutive rows, then flag to move first row to bottom
moveFirstRowToBottom = true;
int nextRowToProcess = x + 1;
int nextConsecutiveRowNumber = rowToMove;
while ((nextRowToProcess <= selectedRows.length - 1) && (selectedRows[nextRowToProcess] == nextConsecutiveRowNumber + 1)) {
rowsToSelect.add(new Integer(selectedRows[nextRowToProcess]));
if (nextRowToProcess == selectedRows.length - 1) {
nextRowToProcess++;
break;
} else {
nextConsecutiveRowNumber = selectedRows[nextRowToProcess];
nextRowToProcess++;
}
}
x = nextRowToProcess - 1;
}
}
if (moveFirstRowToBottom) {
// move first row to bottom
getBrowser().moveRow(0, getRowCount() - 1);
// decrement all the numbers by one, since the first row gets moved to bottom and all rows move up one
rowsToSelect = incrementIntegerNumbers(rowsToSelect, -1);
// add last row to be selected
rowsToSelect.add(new Integer(getRowCount() - 1));
}
refresh();
reselectRows(rowsToSelect);
} finally {
setMovingRows(false);
}
}
}
public void paint (Graphics g) {
while (isCurrentlyPainting()) {
// wait
}
try {
setPainting(true);
super.paint(g);
} catch (Throwable t) {
} finally {
setPainting(false);
}
}
public void refresh () {
getBrowser().refresh();
if (getRowHeaderTable() != null) {
getRowHeaderTable().refresh();
}
}
public void removeFilter (String colname, String value) {
try {
while (isCurrentlyPainting() || isFiltering()) {
}
setFiltering(true);
getBrowser().removeFilter(colname, value);
getBrowser().refreshFilters();
} catch (Throwable t) {
t.printStackTrace();
} finally {
setFiltering(false);
}
}
private void reselectRows (List rowsToSelect) {
if (rowsToSelect != null) {
ListSelectionModel theSelectionModel = getSelectionModel();
theSelectionModel.removeIndexInterval(0, getRowCount());
Iterator schmiterator = rowsToSelect.iterator();
while (schmiterator.hasNext()) {
int rowToSelect = ((Integer) schmiterator.next()).intValue();
theSelectionModel.addSelectionInterval(rowToSelect, rowToSelect);
}
showSelectedRows();
}
}
public void setBrowser (TableBrowser aBrowser) {
this.browser = aBrowser;
}
public void setColumnEditor (int columnIndex, TableCellEditor editor) {
TableColumn tc = getColumnModel().getColumn(columnIndex);
tc.setCellEditor(editor);
}
public void setColumnSelectionInterval (int index0, int index1) {
super.setColumnSelectionInterval(index0, index1);
}
/**
* Sets the column width for the given column. This will automatically turn
* off the column auto resizing feature.
*
* @param index
* the index of the column for which the width should be set
* @param width
* the width for the column.
*/
public void setColumnWidth (int index, int width) {
if (width > -1) {
// Disable auto resizing
this.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
// Get the column by the index
TableColumn c = this.getColumnModel().getColumn(index);
if (width == 0) {
c.setMinWidth(width);
c.setMaxWidth(width);
c.setResizable(false);
}
c.setPreferredWidth(width);
}
}
public void setFiltering (boolean isFiltering) {
this.filtering = isFiltering;
}
protected void setInternalSelectedRows (int[] selectedRows) {
this.internalSelectedRows = selectedRows;
}
public void setMovingRows (boolean moving) {
if (moving) {
while (isMovingRows()) {
// wait
}
}
this.movingRows = moving;
}
public void setPainting (boolean isPainting) {
this.painting = isPainting;
}
public void setRowHeaderTable (RowHeaderTable table) {
this.rowHeaderTable = table;
}
public void setSort (TableSort aSort) {
this.sort = aSort;
}
public void setValueAt (Object aValue, int row, int column) {
super.setValueAt(aValue, row, column);
}
public void showSelectedRows () {
scrollRectToVisible(getCellRect(getSelectedRow(), 0, false));
}
public void valueChanged (ListSelectionEvent aEvt) {
super.valueChanged(aEvt);
if (!isMovingRows()) {
// notify of deselection first
int deselectedRows[] = getInternalSelectedRows();
if (deselectedRows != null && deselectedRows.length > 0) {
// notify each row's listeners
for (int index = 0; index < deselectedRows.length; index++) {
TableRowModel rowModel = (TableRowModel) ((TableBrowserModel) getModel()).getRows().get(deselectedRows[index]);
eventHandler.handleEvent(rowModel, Constants.ITEM_STATE_CHANGED_DESELECTED, this);
}
// notify table's listeners
eventHandler.handleEvent(this.m_tableModel, Constants.ITEM_STATE_CHANGED_DESELECTED, this);
}
// notify of selection, now
int selectedRows[] = getSelectedRows();
if (selectedRows != null && selectedRows.length > 0) {
// notify each row's listeners
for (int index = 0; index < selectedRows.length; index++) {
TableRowModel rowModel = (TableRowModel) ((TableBrowserModel) getModel()).getRows().get(selectedRows[index]);
eventHandler.handleEvent(rowModel, Constants.ITEM_STATE_CHANGED_SELECTED, this);
}
// notify table's listeners
eventHandler.handleEvent(this.m_tableModel, Constants.ITEM_STATE_CHANGED_SELECTED, this);
} else {
// nothing selected
if (this.m_tableModel != null) {
eventHandler.handleEvent(this.m_tableModel, Constants.ITEM_STATE_CHANGED_NONE_SELECTED, this);
}
}
setInternalSelectedRows(selectedRows);
}
}
private String xmlColEnd () {
return "</TBD>";
}
private String xmlColStart (CellDataValue cell, String columnName, boolean selected) {
return "<TBD id=\"" + cell.getKey() + "\" index=\"" + columnName + "\" dirty=\"" + cell.isDirty() + "\" value=\"" + cell.getValue() + "\" selected=\"" + selected + "\">";
}
}
|