Battling JComboBox behavior of removing items

Question

we are working on a document browser GUI and encountered some weird behavioral issue with JComboBox/DefaultComboBoxModel. The current workaround is ugly and we are wondering if there is somehow different way to get it to work.
Our application uses an in-house class to keep a list of documents, and this class has APIs for navigation and deletion so forth. On the GUI, we display a JComboBox to show the name of the current document being viewed. This JComboBox is backed by a DefaultComboBoxModel which has a separate list containing only the names of the document. When a user selects a document from the JComboBox, the application jumps to the selected document, and when a user deletes a document, the corresponding document name is removed from the JComboBox.
The problem is that our in-house class behaves differently than DefaultComboBoxModel. When an item is removed from the in-house class, it points to the next item on the list (i.e. the index value renames the same), unless the last item of the list is removed, and then the index simply points to the new last item of the list. This behavior is intuitive and is in conformation to user requirements.
However, the DefaultComboBoxModel does the opposite with some oddity. When an item is removed from the ComboModel, the selectedIndex points to the previous item the list (i.e. the index value decrements by 1), unless it is the first item of the list, in which case it behaves even more oddly... it points to the next item in the list, but for some reason, the selectedIndex becomes 1 (instead of 0) as if the item to be deleted is still in the list!
So we have been having trouble keeping the in-house class and the JComboBox in sync. For one thing, when a user deletes a document, it renders twice for the next document to be viewed (one triggered by JComboBox automatically points to the previous doc, which is incorrect, and the second one is our code that forces JComboBox to select the next doc by setting selected index), and problems occur especially for the boundary cases. We ended up doing a hack - add an ActionListener to the JComboBox only when it receives a mouse-down event and remove the actionListener inside of the actionPerformed() code, so that we can force the JComboBox to display the correct document name without triggering document rendition.
But this is ugly. We are wondering if there is a better way. One possibility is of course to ditch the defaultComboBoxModel, and implement a mutableComboBoxModel in our in-house class. But is there another way (easier way so we dont have to deal with triggering events etc)? Thanks.

Answer 1

And the way to solve it with a custom MutableComboBoxModel (also does not auto select an item that is added):
import java.awt.*;
import java.util.*;
import javax.swing.*;
public class ListComboBoxModel extends AbstractListModel implements MutableComboBoxModel {
    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                ListComboBoxModel model = new ListComboBoxModel("one", "two", "three");
                model.setSelectionChangeOnRemove(SelectionChange.SELECT_NEXT);
                final JComboBox comboBox = new JComboBox(model);
                comboBox.addActionListener(new ActionListener() {
                    @Override
                    public void actionPerformed(ActionEvent e) {
                        System.out.println("Selected: "
                                + comboBox.getSelectedIndex()
                                + "=" + comboBox.getSelectedItem());
                JFrame frame = new JFrame("Test");
                frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
                frame.getContentPane().add(comboBox, BorderLayout.PAGE_START);
                frame.getContentPane().add(
                        new JButton(new AbstractAction("Delete") {
                            @Override
                            public void actionPerformed(ActionEvent e) {
                                int index = comboBox.getSelectedIndex();
                                System.out.println("Before: " + index
                                        + "=" + comboBox.getSelectedItem());
                                comboBox.removeItemAt(index);
                                System.out.println("After: "
                                        + comboBox.getSelectedIndex()
                                        + "=" + comboBox.getSelectedItem());
                                setEnabled(comboBox.getItemCount() > 0);
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
    public enum SelectionChange { SELECT_PREVIOUS, SELECT_NEXT, CLEAR_SELECTION }
    private final List<Object> items;
    private SelectionChange changeOnRemove = SELECT_PREVIOUS;
    private Object selected;
    public ListComboBoxModel(Object...items) {
        this.items = new ArrayList<Object>();
        if(items != null) {
            this.items.addAll(Arrays.asList(items));
    public void setSelectionChangeOnRemove(SelectionChange changeOnRemove) {
        if(changeOnRemove == null) {
            throw new NullPointerException("SelectionChange should not be null");
        this.changeOnRemove = changeOnRemove;
    @Override
    public int getSize() {
        return items.size();
    @Override
    public Object getElementAt(int index) {
        return items.get(index);
    @Override
    public void setSelectedItem(Object anItem) {
        if((selected != null && !selected.equals(anItem))
                || (selected == null && anItem != null)) {
            selected = anItem;
            fireContentsChanged(this, -1, -1);
    @Override
    public Object getSelectedItem() {
        return selected;
    @Override
    public void addElement(Object obj) {
        insertElementAt(obj, items.size());
    @Override
    public void removeElement(Object element) {
        removeElementAt(items.indexOf(element));
    @Override
    public void insertElementAt(Object element, int index) {
        items.add(index, element);
        fireIntervalAdded(this, index, index);
    @Override
    public void removeElementAt(int index) {
        Object removed = items.get(index);
        if(selected != null && selected.equals(removed)) {
            Object newSelection;
            int size = items.size();
            if(size == 1) {
                newSelection = null;
            else {
                switch(changeOnRemove) {
                case CLEAR_SELECTION:
                    newSelection = null;
                    break;
                case SELECT_NEXT:
                    if(index == size - 1) {
                        newSelection = items.get(index - 1);
                    else {
                        newSelection = items.get(index + 1);
                    break;
                case SELECT_PREVIOUS:
                    if(index == 0) {
                        newSelection = items.get(index + 1);
                    else {
                        newSelection = items.get(index - 1);
                    break;
                default:
                    assert false : "Unknown SelectionChange: " + changeOnRemove;
                    newSelection = null;
                    break;
            setSelectedItem(newSelection);
        items.remove(index);
        fireIntervalRemoved(removed, index, index);
}