/**
* Selects a set of cells.
*
* @param indices an array of the indices of the cells to select
* @see ListSelectionModel#addSelectionInterval
* @see #isSelectedIndex
* @see #addListSelectionListener
*/
public void setCheckBoxListSelectedIndices(int[] indices) {
ListSelectionModel listSelectionModel = getCheckBoxListSelectionModel();
try {
listSelectionModel.setValueIsAdjusting(true);
listSelectionModel.clearSelection();
int size = getModel().getSize();
for (int indice : indices) {
if (indice >= 0 && indice < size) {
listSelectionModel.addSelectionInterval(indice, indice);
}
}
} finally {
listSelectionModel.setValueIsAdjusting(false);
}
}
@Override
public void simpleMatchSelectionChanged(Collection<SimpleMatch> selected) {
// adjust table selection to match match list selection
// FIXME: is this really where I should be doing this?
// selection is the same, don't do anything
Collection<SimpleMatch> tableSelection = getSelectedFromTable();
if (tableSelection.containsAll(selected) && tableSelection.size() == selected.size()) return;
ListSelectionModel lsm = matchTable.getSelectionModel();
lsm.setValueIsAdjusting(true);
lsm.clearSelection();
for (SimpleMatch c : selected) {
int idx = matches.indexOf(c);
lsm.addSelectionInterval(idx, idx);
}
lsm.setValueIsAdjusting(false);
}
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;
}
}
