/**
* Moves the column and heading at <code>columnIndex</code> to <code>newIndex</code>. The old
* column at <code>columnIndex</code> will now be found at <code>newIndex</code>. The column that
* used to be at <code>newIndex</code> is shifted left or right to make room. This will not move
* any columns if <code>columnIndex</code> equals <code>newIndex</code>. This method also posts a
* <code>columnMoved</code> event to its listeners.
*
* @param columnIndex the index of column to be moved
* @param newIndex new index to move the column
* @exception IllegalArgumentException if <code>column</code> or <code>newIndex</code> are not in
* the valid range
*/
public void moveColumn(int columnIndex, int newIndex) {
if ((columnIndex < 0)
|| (columnIndex >= getColumnCount())
|| (newIndex < 0)
|| (newIndex >= getColumnCount()))
throw new IllegalArgumentException("moveColumn() - Index out of range");
TableColumn aColumn;
// If the column has not yet moved far enough to change positions
// post the event anyway, the "draggedDistance" property of the
// tableHeader will say how far the column has been dragged.
// Here we are really trying to get the best out of an
// API that could do with some rethinking. We preserve backward
// compatibility by slightly bending the meaning of these methods.
if (columnIndex == newIndex) {
fireColumnMoved(new TableColumnModelEvent(this, columnIndex, newIndex));
return;
}
aColumn = (TableColumn) tableColumns.elementAt(columnIndex);
tableColumns.removeElementAt(columnIndex);
boolean selected = selectionModel.isSelectedIndex(columnIndex);
selectionModel.removeIndexInterval(columnIndex, columnIndex);
tableColumns.insertElementAt(aColumn, newIndex);
selectionModel.insertIndexInterval(newIndex, 1, true);
if (selected) {
selectionModel.addSelectionInterval(newIndex, newIndex);
} else {
selectionModel.removeSelectionInterval(newIndex, newIndex);
}
fireColumnMoved(new TableColumnModelEvent(this, columnIndex, newIndex));
}
private void moveSelectedRows(int increment) {
if (increment == 0) {
return;
}
if (myEntryTable.isEditing()) {
myEntryTable.getCellEditor().stopCellEditing();
}
final ListSelectionModel selectionModel = myEntryTable.getSelectionModel();
for (int row = increment < 0 ? 0 : myModel.getRowCount() - 1;
increment < 0 ? row < myModel.getRowCount() : row >= 0;
row += increment < 0 ? +1 : -1) {
if (selectionModel.isSelectedIndex(row)) {
final int newRow = moveRow(row, increment);
selectionModel.removeSelectionInterval(row, row);
selectionModel.addSelectionInterval(newRow, newRow);
}
}
myModel.fireTableRowsUpdated(0, myModel.getRowCount() - 1);
Rectangle cellRect = myEntryTable.getCellRect(selectionModel.getMinSelectionIndex(), 0, true);
if (cellRect != null) {
myEntryTable.scrollRectToVisible(cellRect);
}
myEntryTable.repaint();
myListeners.getMulticaster().entryMoved();
}
/**
* Recursive traverse of tree to determine selections A leaf is selected if rsm is selected.
* Nonleaf nodes are selected if all children are selected.
*
* @param tn node in the tree for which to determine selection
* @param nodeidx the ordinal postion in the segments array
* @param gsm the graph segments selection model
* @param rsm the table row selection model
* @return true if given node tn is selected, else false
*/
private boolean selTraverse(
TreeNode tn, int[] nodeidx, ListSelectionModel gsm, ListSelectionModel rsm) {
boolean selected = true;
if (!tn.isLeaf()) {
// A nonleaf node is selected if all its children are selected.
for (int i = 0; i < tn.getChildCount(); i++) {
TreeNode cn = tn.getChildAt(i);
selected &= selTraverse(cn, nodeidx, gsm, rsm);
}
} else {
if (tn instanceof RowCluster) {
// get the row index of the leaf node
int ri = ((RowCluster) tn).getIndex();
// A leaf is selected if its row is selected in the row selection rsm.
selected = rsm.isSelectedIndex(ri);
}
}
// Get the offset into the segments array
int idx = nodeidx[0] * segOffset;
if (selected) {
gsm.addSelectionInterval(idx, idx + (segOffset - 1));
} else {
gsm.removeSelectionInterval(idx, idx + (segOffset - 1));
}
// Increment the nodeidx in the tree
nodeidx[0]++;
return selected;
}
@Override
public void changeSelection(int rowIndex, int columnIndex, boolean toggle, boolean extend) {
ListSelectionModel selectionModel = getSelectionModel();
boolean selected = selectionModel.isSelectedIndex(rowIndex);
if (selected) {
selectionModel.removeSelectionInterval(rowIndex, rowIndex);
} else {
selectionModel.addSelectionInterval(rowIndex, rowIndex);
}
}
/** Updates the list with no feature selected. */
public void unselectAllFeatures() {
// Reset the last row selection of the features table
int numberOfFeatures = getLstFeatures().getRowCount();
if (numberOfFeatures > 0) {
ListSelectionModel model = getLstFeatures().getSelectionModel();
model.removeSelectionInterval(0, numberOfFeatures - 1); // whatever
// row
// selection
}
}
/**
* Updates lead and anchor selection index without changing the selection.
*
* <p>Note: this is c&p'ed from SwingUtilities2 to not have any direct dependency.
*
* @param selectionModel the selection model to change lead/anchor
* @param lead the lead selection index
* @param anchor the anchor selection index
*/
public static void setLeadAnchorWithoutSelection(
ListSelectionModel selectionModel, int lead, int anchor) {
if (anchor == -1) {
anchor = lead;
}
if (lead == -1) {
selectionModel.setAnchorSelectionIndex(-1);
selectionModel.setLeadSelectionIndex(-1);
} else {
if (selectionModel.isSelectedIndex(lead)) selectionModel.addSelectionInterval(lead, lead);
else {
selectionModel.removeSelectionInterval(lead, lead);
}
selectionModel.setAnchorSelectionIndex(anchor);
}
}
private void moveSelectedRows(int increment) {
LOG.assertTrue(increment == -1 || increment == 1);
if (myEntryTable.isEditing()) {
myEntryTable.getCellEditor().stopCellEditing();
}
final ListSelectionModel selectionModel = myEntryTable.getSelectionModel();
for (int row = increment < 0 ? 0 : myModel.getRowCount() - 1;
increment < 0 ? row < myModel.getRowCount() : row >= 0;
row += increment < 0 ? +1 : -1) {
if (selectionModel.isSelectedIndex(row)) {
final int newRow = moveRow(row, increment);
selectionModel.removeSelectionInterval(row, row);
selectionModel.addSelectionInterval(newRow, newRow);
}
}
Rectangle cellRect = myEntryTable.getCellRect(selectionModel.getMinSelectionIndex(), 0, true);
myEntryTable.scrollRectToVisible(cellRect);
myEntryTable.repaint();
}
public void valueChanged(ListSelectionEvent e) {
if (!e.getValueIsAdjusting() && cur == null) { // prevent recursion
ListSelectionModel lsm = (ListSelectionModel) e.getSource();
cur = lsm;
ListSelectionModel rfl; // reflect changes in other model
int mn = lsm.getMinSelectionIndex();
int mx = lsm.getMaxSelectionIndex();
if (lsm == src) {
rfl = dst;
} else {
rfl = src;
}
int min = 0;
int max =
map == null
? lsm.getMaxSelectionIndex()
: lsm == src ? map.getSrcSize() : map.getDstSize();
BitSet bidx = null;
if (map != null && !map.isOneToOne()) {
bidx = new BitSet(max + 1);
}
rfl.setValueIsAdjusting(true);
if (map == null) {
rfl.clearSelection();
}
for (int i = min; i <= max; i++) {
if (map == null) {
if (lsm.isSelectedIndex(i)) {
rfl.addSelectionInterval(i, i);
} else {
rfl.removeSelectionInterval(i, i);
}
} else if (map.isOneToOne()) {
int j = lsm == src ? map.getDst(i) : map.getSrc(i);
if (j < 0) continue;
if (lsm.isSelectedIndex(i)) {
rfl.addSelectionInterval(j, j);
} else {
rfl.removeSelectionInterval(j, j);
}
} else {
// How to deal with OneToMany mapping?
// All dst indices selected -> select src index
// Any dst indices selected -> select src index
//
if (!bidx.get(i)) {
bidx.set(i); // Flag this index as visited
// Get the set of destination indices
int di[] = lsm == src ? map.getDsts(i) : map.getSrcs(i);
if (di != null) {
for (int j = 0; j < di.length; j++) {
if (di[j] < 0) continue;
// Get the set of source indices for each destination index
int si[] = lsm == dst ? map.getDsts(di[j]) : map.getSrcs(di[j]);
if (si != null) {
boolean allSet = true;
boolean anySet = false;
for (int k = 0; k < si.length; k++) {
bidx.set(si[k]); // Flag this index as visited
allSet &= lsm.isSelectedIndex(si[k]);
anySet |= lsm.isSelectedIndex(si[k]);
}
if (allSet || (!allSelected && anySet)) {
rfl.addSelectionInterval(di[j], di[j]);
} else {
rfl.removeSelectionInterval(di[j], di[j]);
}
}
}
}
}
}
}
rfl.setValueIsAdjusting(false);
cur = null;
}
}
