jtablebinding.java

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

         * Sets a name for the column represented by this {@code ColumnBinding}.
         * This is used to initialize the table's column header name. If
         * {@code null} is specified, the {@code toString()} value of the
         * {@code ColumnBinding's} source property is used.
         *
         * @param name the name
         * @return the {@code ColumnBinding} itself, to allow for method chaining
         * @see javax.swing.table.TableModel#getColumnName
         */
        public ColumnBinding setColumnName(String name) {
            JTableBinding.this.throwIfBound();
            this.columnName = name;
            return this;
        }

        /**
         * Sets the column class to be used by {@code JTable} to determine
         * the renderer and editor for the column represented by this
         * {@code ColumnBinding}.
         *
         * @param columnClass the column class
         * @return the {@code ColumnBinding} itself, to allow for method chaining
         * @see javax.swing.table.TableModel#getColumnClass
         */
        public ColumnBinding setColumnClass(Class<?> columnClass) {
            JTableBinding.this.throwIfBound();
            this.columnClass = columnClass;
            return this;
        }

        /**
         * Returns the column class to be used by {@code JTable} to determine
         * the renderer and editor for the column represented by this
         * {@code ColumnBinding}.
         *
         * @see #setColumnClass
         * @see javax.swing.table.TableModel#getColumnClass
         */
        public Class<?> getColumnClass() {
            return columnClass == null ? Object.class : columnClass;
        }

        /**
         * Returns the name for the column represented by this {@code ColumnBinding}.
         * This is used to initialize the table's column header name.  If no name
         * has been specified, or if it has been set to {@code null}, the
         * {@code toString()} value of the {@code ColumnBinding's} source property is returned.
         *
         * @return the name for the column
         * @see #setColumnName
         * @see javax.swing.table.TableModel#getColumnName
         */
        public String getColumnName() {
            return columnName == null ? getSourceProperty().toString() : columnName;
        }

        /**
         * Sets whether or not the cells of the column should be editable.
         * The default for this property is {@code true}.
         * See this <a href="JTableBinding.html#EDITABILITY">paragraph</a> in the class level
         * documentation on editability.
         *
         * @param editable whether or not the cells of the column should be editable
         * @return the {@code ColumnBinding} itself, to allow for method chaining
         */
        public ColumnBinding setEditable(boolean editable) {
            this.editable = editable;
            return this;
        }

        /**
         * Returns whether or not the cells of the column should be editable.
         * The default for this property is {@code true}.
         * See this <a href="JTableBinding.html#EDITABILITY">paragraph</a> in the class level
         * documentation on editability.
         *
         * @return whether or not the cells of the column should be editable
         */
        public boolean isEditable() {
            return editable;
        }

        private void bindUnmanaged0() {
            bindUnmanaged();
        }
        
        private void unbindUnmanaged0() {
            unbindUnmanaged();
        }

        private SyncFailure saveUnmanaged0() {
            return saveUnmanaged();
        }

        private void setSourceObjectUnmanaged0(Object source) {
            setSourceObjectUnmanaged(source);
        }
    }

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

            if (pse.getSourceProperty() == tableP) {
                cleanupForLast();
                
                boolean wasAccessible = isTableAccessible(pse.getOldValue());
                boolean isAccessible = isTableAccessible(pse.getNewValue());

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

                if (table == null) {
                    table = tableP.getValue(getTargetObject());
                    model = new BindingTableModel();
                    table.setModel(model);
                }

                model.setElements((List)pse.getNewValue(), true);
            }
        }
    }

    private final class BindingTableModel extends ListBindingManager implements TableModel  {
        private final List<TableModelListener> listeners;

        public BindingTableModel() {
            listeners = new CopyOnWriteArrayList<TableModelListener>();
        }

        protected AbstractColumnBinding[] getColBindings() {
            AbstractColumnBinding[] bindings = new AbstractColumnBinding[getColumnBindings().size()];
            bindings = getColumnBindings().toArray(bindings);
            return bindings;
        }

        public int getRowCount() {
            return size();
        }

        public Object getValueAt(int rowIndex, int columnIndex) {
            return valueAt(rowIndex, columnIndex);
        }

        public void setValueAt(Object value, int rowIndex, int columnIndex) {
            ColumnBinding cb = JTableBinding.this.getColumnBinding(columnIndex);
            BindingListener[] cbListeners = cb.getBindingListeners();
            BindingListener[] tbListeners = getBindingListeners();
            
            cb.setSourceObjectUnmanaged0(this.getElement(rowIndex));
            cb.setEditingObject(value);
            cb.bindUnmanaged0();
            
            for (BindingListener listener : tbListeners) {
                listener.bindingBecameBound(cb);
            }
            
            PropertyStateEvent pse = new PropertyStateEvent(cb.getTargetProperty(),
                    cb.getTargetObject(),
                    true,
                    getValueAt(rowIndex, columnIndex),
                    value,
                    false,
                    cb.getSourceProperty().isWriteable(cb.getSourceObject()));
            
            for (BindingListener listener : cbListeners) {
                listener.targetChanged(cb, pse);
            }
            
            for (BindingListener listener : tbListeners) {
                listener.targetChanged(cb, pse);
            }
            
            SyncFailure failure = cb.saveUnmanaged0();
            
            if (failure == null) {
                for (BindingListener listener : cbListeners) {
                    listener.synced(cb);
                }
                
                for (BindingListener listener : tbListeners) {
                    listener.synced(cb);
                }
            } else {
                for (BindingListener listener : cbListeners) {
                    listener.syncFailed(cb, failure);
                }
                
                for (BindingListener listener : tbListeners) {
                    listener.syncFailed(cb, failure);
                }
            }

            cb.unbindUnmanaged0();
            
            for (BindingListener listener : tbListeners) {
                listener.bindingBecameUnbound(cb);
            }
            
            cb.setEditingObject(null);
            cb.setSourceObjectUnmanaged0(null);
        }

        public Class<?> getColumnClass(int columnIndex) {
            Class<?> klass = JTableBinding.this.getColumnBinding(columnIndex).getColumnClass();
            return klass == null ? Object.class : klass;
        }

        protected void allChanged() {
            fireTableModelEvent(new TableModelEvent(this, 0, Integer.MAX_VALUE));
        }

        protected void valueChanged(int row, int column) {
            fireTableModelEvent(new TableModelEvent(this, row, row, column));
        }

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

            fireTableModelEvent(new TableModelEvent(this, row, row + length - 1, TableModelEvent.ALL_COLUMNS, TableModelEvent.INSERT));
        }

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

            fireTableModelEvent(new TableModelEvent(this, row, row + length - 1, TableModelEvent.ALL_COLUMNS, TableModelEvent.DELETE));
        }

        protected void changed(int row) {
            fireTableModelEvent(new TableModelEvent(this, row, row, TableModelEvent.ALL_COLUMNS));
        }

        public String getColumnName(int columnIndex) {
            ColumnBinding binding = JTableBinding.this.getColumnBinding(columnIndex);
            return binding.getColumnName() == null ? binding.getSourceProperty().toString() : binding.getColumnName();
        }

        public boolean isCellEditable(int rowIndex, int columnIndex) {
            if (!JTableBinding.this.isEditable()) {
                return false;
            }

            ColumnBinding binding = JTableBinding.this.getColumnBinding(columnIndex);
            if (!binding.isEditable()) {
                return false;
            }

            return binding.getSourceProperty().isWriteable(getElement(rowIndex));
        }

        public void addTableModelListener(TableModelListener l) {
            listeners.add(l);
        }

        public void removeTableModelListener(TableModelListener l) {
            listeners.remove(l);
        }

        private void fireTableModelEvent(TableModelEvent e) {
            for (TableModelListener listener : listeners) {
                listener.tableChanged(e);
            }
        }

        public int getColumnCount() {
            return columnCount();
        }
    }

}