Q1

private void createView() {

boardView = new JTable(new AbstractTableModel() {
public int getColumnCount() {
return boardModel.colNb();
}
public int getRowCount() {
return boardModel.rowNb();
}
public Object getValueAt(int rowIndex, int columnIndex) {
Coord c = new Coord(rowIndex, columnIndex);
return boardModel.pieceAt(c);
}
});
boardView.setRowHeight(CELL_SIZE);
boardView.setPreferredSize(
new Dimension(
CELL_SIZE * boardModel.colNb(),
CELL_SIZE * boardModel.rowNb()));
boardView.setCellSelectionEnabled(false);
}

Q2
private void placeComponents() {
GBC[] cst = new GBC[] {
new GBC(1, 0).weight(1, 1),
new GBC(2, 0).weight(1, 0),
new GBC(3, 0).weight(1, 0),
new GBC(4, 0).weight(1, 0),
new GBC(5, 0).weight(1, 0),
new GBC(6, 0).weight(1, 0),
new GBC(7, 0).weight(1, 0),
new GBC(8, 0).weight(1, 0),
new GBC(0, 1).weight(1, 1),
new GBC(0, 2).weight(0, 1),
new GBC(0, 3).weight(0, 1),
new GBC(0, 4).weight(0, 1),
new GBC(0, 5).weight(0, 1),
new GBC(0, 6).weight(0, 1),
new GBC(0, 7).weight(0, 1),
new GBC(0, 8).weight(0, 1),
new GBC(1, 1, 8, 8)
};
setLayout(new GridBagLayout()); {
int cn = boardModel.colNb();
for (int i = 0; i < cn; i++) {
add(new JLabel(boardModel.colName(i)), cst[i]);
}
int rn = boardModel.rowNb();
for (int i = 0; i < rn; i++) {
add(new JLabel(boardModel.rowName(i)), cst[cn + i]);
}
add(boardView, cst[rn + cn]);
}
}

Q3
boardView.addMouseListener(new MouseAdapter() {
@Override
 public void mouseReleased(MouseEvent e) {
int row = boardView.rowAtPoint(e.getPoint());
int col = boardView.columnAtPoint(e.getPoint());
Coord c = new Coord(row, col);
if (boardModel.getSource() == null) {
if (boardModel.pieceAt(c) != null) {
boardModel.setSource(c);
} else {
Toolkit.getDefaultToolkit().beep();
}
} else {
if (c.equals(boardModel.getSource())) {
boardModel.resetSource();
} else {
boardModel.setTarget(c);
if (boardModel.moveAccepted()) {
boardModel.move();
} else {
Toolkit.getDefaultToolkit().beep();
boardModel.resetPositions();
}
}
}
}
});

Q4
public class ChangeSupport {
private EventListenerList listenersList;
private final ChangeEvent event;
public ChangeSupport(IBoardModel owner) {
event = new ChangeEvent(owner);
}
public ChangeListener[] getChangeListeners() {
if (listenersList == null) {
return new ChangeListener[0];
}
return listenersList.getListeners(ChangeListener.class);
}
public void addChangeListener(ChangeListener listener) {
if (listener == null) {
return;
}
if (listenersList == null) {
listenersList = new EventListenerList();
}
listenersList.add(ChangeListener.class, listener);
}
public void removeChangeListener(ChangeListener listener) {
if (listener == null || listenersList == null) {
return;
}
listenersList.remove(ChangeListener.class, listener);
}
public void fireStateChanged() {
ChangeListener[] list = getChangeListeners();
if (list.length > 0) {
for (ChangeListener lst : list) {
lst.stateChanged(event);
 }
}
}
}
* Dans BoardModel :
private final ChangeSupport boardSupport;
public BoardModel() {
...
boardSupport = new ChangeSupport(this);
}
public void addChangeListener(ChangeListener lst) {
boardSupport.addChangeListener(lst);
}
public void move() {
...
boardSupport.removeChangeListener(lst);
}
public void removeChangeListener(ChangeListener lst) {
...
boardSupport.removeChangeListener(lst);
}
public void resetPositions() {
...
boardSupport.fireStateChanged();
}
public void resetSource() {
...
boardSupport.fireStateChanged();
}
public void setSource(Coord c) {
...
boardSupport.fireStateChanged();
}
public void setTarget(Coord c) {
...
boardSupport.fireStateChanged();
}

Q5
boardModel.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent e) {
repaint();
}
});

Q6
public class BoardCellRenderer implements TableCellRenderer {
...
public BoardCellRenderer(IBoardModel m) {
if (m == null) {
throw new IllegalArgumentException();
}
model = m;
delegate = new JLabel();
delegate.setOpaque(true);
delegate.setHorizontalAlignment(JLabel.CENTER);
}
public Component getTableCellRendererComponent(
JTable table, Object value, boolean isSelected, boolean hasFocus,
 int row, int column) {
Coord c = new Coord(row, column);
if (c.equals(model.getSource())) {
delegate.setBackground(SOURCE_CELL);
} else if (c.equals(model.getTarget())) {
delegate.setBackground(TARGET_CELL);
} else {
if ((row % 2) != (column % 2)) {
delegate.setBackground(BLACK_CELL);
} else {
delegate.setBackground(WHITE_CELL);
}
}
IPiece p = (IPiece) value;
if (p == null) {
delegate.setText(EMPTY);
delegate.setForeground(BLACK);
} else {
delegate.setText(p.stringRep());
delegate.setForeground(p.color());
}
return delegate;
}
}

Q7
boardView.setDefaultRenderer(
Object.class,
new BoardCellRenderer(boardModel));

Q8
public class TimedSwitcher extends Thread implements ITimedSwitcher {
private boolean on;
private Runnable beginCode;
private Runnable endCode;
private volatile int delay;
public TimedSwitcher(Runnable bCode, Runnable eCode) {
if (bCode == null || eCode == null) {
throw new IllegalArgumentException();
}
on = false;
beginCode = bCode;
endCode = eCode;
delay = DELAY;
setDaemon(true);
}
public Runnable begin() {
return beginCode;
}
public int delay() {
return delay;
}
public Runnable end() {
return endCode;
}
public void run() {
while (true) {
waitUntilOn();
beginCode.run();
 try {
Thread.sleep(delay);
} catch (InterruptedException e) {
// rien, on continue
}
endCode.run();
}
}
public synchronized void trigger() {
on = true;
notify();
}
public synchronized void setDelay(int d) {
if (d < 0) {
throw new IllegalArgumentException();
}
delay = d;
}
private synchronized void waitUntilOn() {
while (!on) {
try {
wait();
} catch (InterruptedException e) {
// rien, on continue
}
}
on = false;
}
}

Q9
* Définir dans Board
private MouseListener mouseController;
private TimedSwitcher switcher;
* Initialiser mouseController avec le MouseListener interne anonyme de la question
Q3
* Ajouter dans la méthode createController :
Runnable begin = new Runnable() {
public void run() {
boardView.removeMouseListener(mouseController);
}
};
Runnable end = new Runnable() {
public void run() {
boardModel.move();
boardView.addMouseListener(mouseController);
}
};
switcher = new TimedSwitcher(begin, end);
switcher.start();
* Ne pas oublier de remplacer dans mouseController :
boardModel.move();
par :
switcher.trigger();