Mein Beispiel war eigentlich ganz nett, bis ich merke, dass es so nicht funktioniert, weil ich unverändlicher Objekte im Model habe, die ich nicht unterscheiden kann X-D
Da war der Schaden aber schon angerichtet und meine Kreativität reichte nicht mehr für ein neues Beispiel. :(
Das Ganze sieht wieder einmal nach extrem viel Code aus. Die wichtigen Punkte sind aber kurz und habe ich als Prosa hingeschrieben. Damit es anschaulich ist, sollte es aber IMHO schon ein funktionieredes Beispiel sein.
Und sonst probier es mal ohne MVC. ;)
Zuerst das ComboBoxModel. Die wichtige Methode hier ist #setSelectedItem die aufgeruft wird, wenn ein Item selektiert wird. Hier könntest du dann Daten an den Server schicken. Zudem habe ich eine Methode gemacht, die der Editor aufrufen wird, wenn er das selektierte Item geändert hat, um das GUI zu updaten. Sonst ist das ganze sehr allgemein und totsimpel.
Die #example methode ignorierst du am besten einfach und den Trick mit dem cast brauchst du nicht zu schnallen.
package gui.sanchez;
import java.util.ArrayList;
import java.util.List;
import javax.swing.AbstractListModel;
import javax.swing.ComboBoxModel;
public class ListComboModel<T> extends AbstractListModel implements ComboBoxModel {
private List<T> items;
private T selectedItem;
private Class<T> token;
public ListComboModel(Class<T> token, List<T> items) {
super();
this.token = token;
this.items = items;
}
public void setSelectedItem(Object anItem) {
this.selectedItem = this.token.cast(anItem);
}
public void changedAtSelection() {
// update UI
int selectionIndex = this.items.indexOf(this.selectedItem);
this.fireContentsChanged(this, selectionIndex, selectionIndex);
}
public T getSelectedItem() {
if (this.selectedItem == null && !this.items.isEmpty()) {
this.selectedItem = this.items.get(0);
}
return this.selectedItem;
}
public int getSize() {
return this.items.size();
}
public T getElementAt(int index) {
return this.items.get(index);
}
public static ListComboModel<ValueHolder> example() {
//XXX raw types
List<ValueHolder> chars = new ArrayList<ValueHolder>();
for (Character each : new Character[] {'S' , 'W', 'I' , 'N' , 'G'}) {
chars.add(new ValueHolder<Character>(each));
}
ListComboModel<ValueHolder> model = new ListComboModel<ValueHolder>(ValueHolder.class, chars);
return model;
}
}
Hier ist der eigene Editor. Eigentlich bloss ein JSpinner mit einem JTextField und einem eigenen Modell. Es gibt zwei Listener, einer updated das das Model und der andere JTextField. Der letztere ist nicht ganz sauber, ich weiss. Das JTextField ist eigentlich nur zu Layout-Zwecken da. Du kannst es und den entsprechenden Listener auch weglassen.
package gui.sanchez;
import java.awt.Component;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import javax.swing.ComboBoxEditor;
import javax.swing.JSpinner;
import javax.swing.JTextField;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
public class CharacterEditor implements ComboBoxEditor {
private JSpinner editor;
protected JTextField textField;
private List<ActionListener> listeners;
private SpinnerCharacterModel spinnerModel;
private ValueHolder<Object> item;
protected ListComboModel<ValueHolder<Character>> model;
public CharacterEditor(char start, char end, ListComboModel<ValueHolder<Character>> model) {
this.model = model;
this.spinnerModel = new SpinnerCharacterModel(start, end);
this.editor = new JSpinner(this.spinnerModel);
this.editor.addChangeListener(new CharacterListener());
this.textField = new JTextField(8);
this.textField.setEditable(false);
this.editor.setEditor(this.textField);
CharacterPropagator listener = new CharacterPropagator();
this.editor.addChangeListener(listener);
this.listeners = new CopyOnWriteArrayList<ActionListener>();
}
public void addChangeListener(ChangeListener l) {
this.editor.addChangeListener(l);
}
public Component getEditorComponent() {
return this.editor;
}
public void setItem(Object anObject) {
// XXX unsafe cast
this.item = (ValueHolder<Object>) anObject;
this.spinnerModel.setValue(this.item.getContents());
this.notifyListeners();
}
public Object getItem() {
this.item.setContents(this.editor.getValue());
return this.item;
}
public void selectAll() {
//nothing
}
public synchronized void addActionListener(ActionListener l) {
this.listeners.add(l);
}
public synchronized void removeActionListener(ActionListener l) {
this.listeners.remove(l);
}
private void notifyListeners() {
ActionEvent e = new ActionEvent(this, 0, "edit");
for (ActionListener each : this.listeners) {
each.actionPerformed(e);
}
}
private class CharacterListener implements ChangeListener {
public void stateChanged(ChangeEvent e) {
JSpinner source = (JSpinner) e.getSource();
String value = source.getValue().toString();
CharacterEditor.this.textField.setText(value);
}
}
private class CharacterPropagator implements ChangeListener {
public void stateChanged(ChangeEvent e) {
JSpinner source = (JSpinner) e.getSource();
Character newValue = (Character) source.getValue();
ValueHolder<Character> holder = CharacterEditor.this.model.getSelectedItem();
Character oldValue = holder.getContents();
if (!newValue.equals(oldValue)) {
holder.setContents(newValue);
CharacterEditor.this.model.changedAtSelection();
}
}
}
}
Das Model für den Spinner, auch hier gibt es eigentlich nichts zu sehen. Eine obere Grenze, eine untere, das wars.
package gui.sanchez;
import javax.swing.AbstractSpinnerModel;
public class SpinnerCharacterModel extends AbstractSpinnerModel {
private char start, end, selected;
public SpinnerCharacterModel(char start, char end) {
this.start = start;
this.end = end;
}
public Character getValue() {
return this.selected;
}
public void setValue(Object value) {
this.selected = (Character) value;
this.fireStateChanged();
}
public Character getNextValue() {
if (this.selected >= this.end) {
return null;
}
return (char) (this.selected + 1);
}
public Character getPreviousValue() {
if (this.selected <= this.start) {
return null;
}
return (char) (this.selected - 1);
}
}
Und der Vollständigkeit halber. Das ist ein spezieller hack für mein Beispiel und braucht dich nicht zu interessieren.
Das Problem ist wenn ich nur Characters im ComboBoxModel habe, kann ich nicht genau sagen, welcher ausgewählt wurde, wenn mehrmals der gleiche vorkommt. Das wäre kein Problem wenn Characters mutable wären und der Editor den Wert des ausgewählten ändern kann.
Ok, ich hätte jetzt einen Identitätsvergleich machen können aber dann wäre das Modell weniger allgemein. Dafür wäre das Beispiel einfacher.
package gui.sanchez;
public class ValueHolder<T> {
private T contents;
public ValueHolder(T contents) {
this.contents = contents;
}
public T getContents() {
return this.contents;
}
public void setContents(T contents) {
this.contents = contents;
}
public String toString() {
return this.contents.toString();
}
}
Und noch etwas Code um das Ganze laufen zu lassen
Der wichtige Punkt ist combo.setEditor(editor); bei dem ich der ComboBox einen eigenen Editor angebe, der das Model updatet und natürlich new JComboBox(model); das die JComboBox auf dem Model erstellt.
package gui.sanchez;
import static javax.swing.SwingUtilities.invokeLater;
import static javax.swing.WindowConstants.EXIT_ON_CLOSE;
import javax.swing.BorderFactory;
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class CharacterComboDemo {
private static JComponent createPanel() {
JPanel panel = new JPanel();
// XXX unsafe cast
ListComboModel<ValueHolder<Character>> model = (ListComboModel<ValueHolder<Character>>) ListComboModel.example();
CharacterEditor editor = new CharacterEditor('A', 'Z', model);
JComboBox combo = new JComboBox(model);
combo.setEditor(editor);
combo.setEditable(true);
panel.add(combo);
return panel;
}
protected static void createAndShowGUI() {
JFrame.setDefaultLookAndFeelDecorated(true);
JFrame frame = new JFrame("CharacterComboDemo");
frame.setDefaultCloseOperation(EXIT_ON_CLOSE);
JComponent newContentPane = createPanel();
newContentPane.setOpaque(true);
newContentPane.setBorder(BorderFactory.createEmptyBorder(12, 12, 11, 11));
frame.setContentPane(newContentPane);
frame.pack();
frame.setVisible(true);
}
public static void main(String[] args) {
System.setProperty("swing.aatext", "true");
invokeLater(new Runnable() {
public void run() {
createAndShowGUI();
}
});
}
}