Scrivo un esempio completo. Il problema generale è che una tabella supporta una varietà di modelli di selezione e il caso peggiore è certamente quello in cui tutti questi modelli siano desiderati. Vale a dire che è più facile trattare l'esclusione di una cella dalla selezione qualora il modello di selezione preveda esclusivamente l'accesso ad una singola cella per volta. JTable, al contrario, autorizza normalmente la selezione di più colonne ed eventualmente di una singola cella all'interno di una di queste. Detto questo, l'esempio parte con un oggetto in grado di stabilire quali singole celle all'interno della tabella non siano selezionabili.
import java.awt.Point;
import java.util.*;
public class SelectionData {
private ArrayList<Point> unselectableCells = new ArrayList<Point>();
public SelectionData(int...cellCoords) {
for(int i = 0; i < cellCoords.length; i += 2) {
unselectableCells.add(new Point(cellCoords[i], cellCoords[i + 1]));
}
}
public boolean canSelectCell(int row, int col) {
Point p = new Point(row, col);
return unselectableCells.contains(p) == false;
}
}
Volendo istruire SelectionData ad escludere le celle (0, 0) e (3, 4), lo si creerà con:
SelectionData sd = new SelectionData(0, 0, 3, 4);
Non ho trovato un nome migliore di SelectionData :D.
Il resto si appoggia a questo strumento. Il primo di questo resto è il proiettore delle celle. Il proiettore si rende necessario qualora il modello di selezione della tabella consenta di scegliere intere righe o colonne. Il proiettore fa sì che una cella abbia l'aspetto "non selezionato" quando, date le sue coordinate, essa risulti non selezionabile.
import java.awt.*;
import javax.swing.*;
import javax.swing.table.*;
public class MyRenderer extends DefaultTableCellRenderer {
private SelectionData selectionData;
public MyRenderer(SelectionData selectionData) {
this.selectionData = selectionData;
}
public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
if(selectionData.canSelectCell(row, column) == false) {
isSelected = false;
hasFocus = false;
}
return super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
}
}
Il secondo componente che si appoggia a SelectionData è una tabella personalizzata. La personalizzazione sta in ciò che la tabella esclude la possibilità di mutare il valore di una cella non selezionabile oltre ad indicare come non selezionata una cella se ciò sia escluso da SelectionData.
import javax.swing.*;
public class MyTable extends JTable {
private SelectionData selectionData;
public MyTable(SelectionData selectionData) {
this.selectionData = selectionData;
}
public boolean isCellSelected(int row, int col) {
boolean answer = super.isCellSelected(row, col);
return answer ? selectionData.canSelectCell(row, col) : false;
}
public boolean isCellEditable(int row, int col) {
boolean answer = super.isCellEditable(row, col);
return answer ? selectionData.canSelectCell(row, col) : false;
}
}
Il terzo incomodo è l'oggetto che gestisce la mutazione di selezione in corrispondenza della pressione dei tasti di controllo. L'esempio contiene unicamente il trattamento del tasto "tab" ma è facile estenderlo anche alle frecce. E' un KeyListener. Gli eventi di pressione di un tasto sono propagati dalla tabella prima che essi si riflettano sui suoi due ListSelectionModel.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class SelectionKeyManager extends KeyAdapter {
private SelectionData selectionData;
private JTable table;
private ListSelectionModel rowSelectionModel, colSelectionModel;
public SelectionKeyManager(SelectionData selectionData, JTable table) {
this.selectionData = selectionData;
this.table = table;
rowSelectionModel = table.getSelectionModel();
colSelectionModel = table.getColumnModel().getSelectionModel();
}
public void keyPressed(KeyEvent e) {
if(e.getKeyCode() == KeyEvent.VK_TAB) {
if((e.getModifiersEx() & InputEvent.SHIFT_DOWN_MASK) == InputEvent.SHIFT_DOWN_MASK) {
previousColumn();
} else {
nextColumn();
}
} else if(e.getKeyCode() == KeyEvent.VK_UP) {
} else if(e.getKeyCode() == KeyEvent.VK_LEFT) {
} else if(e.getKeyCode() == KeyEvent.VK_RIGHT) {
} else if(e.getKeyCode() == KeyEvent.VK_DOWN) {
}
}
private void previousColumn() {
int row = rowSelectionModel.getLeadSelectionIndex();
int col = colSelectionModel.getLeadSelectionIndex() - 1;
if(row < 0) {
row = table.getRowCount() - 1;
}
if(col < 0) {
col = table.getColumnCount() - 1;
}
boolean canSelect = selectionData.canSelectCell(row, col);
if(!canSelect) {
colSelectionModel.setLeadSelectionIndex(col);
}
}
private void nextColumn() {
int row = rowSelectionModel.getLeadSelectionIndex();
int col = colSelectionModel.getLeadSelectionIndex() + 1; //key press invocato prima della mutazione di selezione
if(row < 0) {
row = 0;
}
if(col == table.getColumnCount()) {
row++;
if(row == table.getRowCount()) {
row = 0;
rowSelectionModel.setSelectionInterval(0, 0);
}
col = 0;
}
boolean canSelect = selectionData.canSelectCell(row, col);
if(!canSelect) {
colSelectionModel.setLeadSelectionIndex(col);
}
}
private void cellUp() {
}
private void cellDown() {
}
private void cellLeft() {
}
private void cellRight() {
}
}
La classe Main che segue mette insieme il tutto.
import java.awt.*;
import javax.swing.*;
import javax.swing.table.*;
public class Main implements Runnable {
public static void main(String[] args) {
SwingUtilities.invokeLater(new Main());
}
public void run() {
DefaultTableModel tableModel = new DefaultTableModel(5, 10);
SelectionData selectionData = new SelectionData(0, 0, 1, 1, 2, 2, 3, 3);
MyTable table = new MyTable(selectionData);
table.setModel(tableModel);
MyRenderer renderer = new MyRenderer(selectionData);
table.setDefaultRenderer(Object.class, renderer);
SelectionKeyManager selectionKeyManager = new SelectionKeyManager(selectionData, table);
table.addKeyListener(selectionKeyManager);
JScrollPane scrollPane = new JScrollPane(table);
JFrame window = new JFrame("Table sample");
window.add(scrollPane);
window.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
window.pack();
window.setVisible(true);
}
}
Ci sono delle alternative. Puoi definire un tuo ListSelectionModel (ne servono due, uno per le righe e uno per le colonne). Personalmente ritengo più semplice intervenire "dall'esterno", manipolando l'input, anzichè dall'interno, sostituendo in toto il modello di selezione della tabella. La questione della semplicità è tuttavia sempre personale e opinabile.