jcomboboxbinding.java

java属性邦定的（JSR-295）的一个实现

        comboP.addPropertyStateListener(getTargetObject(), handler);
        elementsP.addPropertyStateListener(null, handler);
        super.bindImpl();
    }

    protected void unbindImpl() {
        elementsP.removePropertyStateListener(null, handler);
        comboP.removePropertyStateListener(getTargetObject(), handler);
        elementsP.setAccessible(false);
        cleanupForLast();
        super.unbindImpl();
    }

    private boolean isComboAccessible() {
        return comboP.isReadable(getTargetObject()) && comboP.getValue(getTargetObject()) != null;
    }

    private boolean isComboAccessible(Object value) {
        return value != null && value != PropertyStateEvent.UNREADABLE;
    }

    private void cleanupForLast() {
        if (combo == null) {
            return;
        }

        combo.setSelectedItem(null);
        combo.setModel(new DefaultComboBoxModel());
        model.updateElements(null, combo.isEditable());
        combo = null;
        model = null;
    }

    private class Handler implements PropertyStateListener {
        public void propertyStateChanged(PropertyStateEvent pse) {
            if (!pse.getValueChanged()) {
                return;
            }

            if (pse.getSourceProperty() == comboP) {
                cleanupForLast();
                
                boolean wasAccessible = isComboAccessible(pse.getOldValue());
                boolean isAccessible = isComboAccessible(pse.getNewValue());

                if (wasAccessible != isAccessible) {
                    elementsP.setAccessible(isAccessible);
                } else if (elementsP.isAccessible()) {
                    elementsP.setValueAndIgnore(null, null);
                }
            } else {
                if (((ElementsProperty.ElementsPropertyStateEvent)pse).shouldIgnore()) {
                    return;
                }

                if (combo == null) {
                    combo = comboP.getValue(getTargetObject());
                    combo.setSelectedItem(null);
                    model = new BindingComboBoxModel();
                    combo.setModel(model);
                }

                model.updateElements((List)pse.getNewValue(), combo.isEditable());
            }
        }
    }

    private final class BindingComboBoxModel extends ListBindingManager implements ComboBoxModel  {
        private final List<ListDataListener> listeners;
        private Object selectedItem = null;
        private int selectedModelIndex = -1;

        public BindingComboBoxModel() {
            listeners = new CopyOnWriteArrayList<ListDataListener>();
        }

        public void updateElements(List<?> elements, boolean isEditable) {
            setElements(elements, false);

            if (!isEditable || selectedModelIndex != -1) {
                selectedItem = null;
                selectedModelIndex = -1;
            }
            
            if (size() <= 0) {
                if (selectedModelIndex != -1) {
                    selectedModelIndex = -1;
                    selectedItem = null;
                }
            } else {
                if (selectedItem == null) {
                    selectedModelIndex = 0;
                    selectedItem = getElementAt(selectedModelIndex);
                }
            }

            allChanged();
        }

        protected AbstractColumnBinding[] getColBindings() {
            return new AbstractColumnBinding[0];
        }

        public Object getSelectedItem() {
            return selectedItem;
        }

        public void setSelectedItem(Object item) {
            // This is what DefaultComboBoxModel does (yes, yuck!)
            if ((selectedItem != null && !selectedItem.equals(item)) || selectedItem == null && item != null) {
                selectedItem = item;
                contentsChanged(-1, -1);
                selectedModelIndex = -1;
                if (item != null) {
                    int size = size();
                    for (int i = 0; i < size; i++) {
                        if (item.equals(getElementAt(i))) {
                            selectedModelIndex = i;
                            break;
                        }
                    }
                }
            }
        }

        protected void allChanged() {
            contentsChanged(0, size());
        }

        protected void valueChanged(int row, int column) {
            // we're not expecting any value changes since we don't have any
            // detail bindings for JComboBox
        }

        protected void added(int index, int length) {
            assert length > 0; // enforced by ListBindingManager

            ListDataEvent e = new ListDataEvent(this, ListDataEvent.INTERVAL_ADDED, index, index + length - 1);
            int size = listeners.size();
            for (int i = size - 1; i >= 0; i--) {
                listeners.get(i).intervalAdded(e);
            }

            if (size() == length && selectedItem == null) {
                setSelectedItem(getElementAt(0));
            }
        }

        protected void removed(int index, int length) {
            assert length > 0; // enforced by ListBindingManager

            ListDataEvent e = new ListDataEvent(this, ListDataEvent.INTERVAL_REMOVED, index, index + length - 1);
            int size = listeners.size();
            for (int i = size - 1; i >= 0; i--) {
                listeners.get(i).intervalRemoved(e);
            }
            
            if (selectedModelIndex >= index && selectedModelIndex < index + length) {
                if (size() == 0) {
                    setSelectedItem(null);
                } else {
                    setSelectedItem(getElementAt(Math.max(index - 1, 0)));
                }
            }
        }

        protected void changed(int row) {
            contentsChanged(row, row);
        }

        private void contentsChanged(int row0, int row1) {
            ListDataEvent e = new ListDataEvent(this, ListDataEvent.CONTENTS_CHANGED, row0, row1);
            int size = listeners.size();
            for (int i = size - 1; i >= 0; i--) {
                listeners.get(i).contentsChanged(e);
            }
        }
        
        public Object getElementAt(int index) {
            return getElement(index);
        }
        
        public void addListDataListener(ListDataListener l) {
            listeners.add(l);
        }
        
        public void removeListDataListener(ListDataListener l) {
            listeners.remove(l);
        }
        
        public int getSize() {
            return size();
        }
    }

}