/* * Copyright (c) 1997, 2007, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation.  Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package javax.swing; import java.awt.Component;import java.awt.event.*;import java.beans.ConstructorProperties;import java.lang.Boolean;import javax.swing.table.*;import javax.swing.event.*;import java.util.EventObject;import javax.swing.tree.*;import java.io.Serializable; /** * The default editor for table and tree cells. * <p> * <strong>Warning:</strong> * Serialized objects of this class will not be compatible with * future Swing releases. The current serialization support is * appropriate for short term storage or RMI between applications running * the same version of Swing.  As of 1.4, support for long term storage * of all JavaBeans<sup><font size="-2">TM</font></sup> * has been added to the <code>java.beans</code> package. * Please see {@link java.beans.XMLEncoder}. * * @author Alan Chung * @author Philip Milne */ public class DefaultCellEditor extends AbstractCellEditor    implements TableCellEditor, TreeCellEditor { ////  Instance Variables//     /** The Swing component being edited. */    protected JComponent editorComponent;    /**     * The delegate class which handles all methods sent from the     * <code>CellEditor</code>.     */    protected EditorDelegate delegate;    /**     * An integer specifying the number of clicks needed to start editing.     * Even if <code>clickCountToStart</code> is defined as zero, it     * will not initiate until a click occurs.     */    protected int clickCountToStart = 1; ////  Constructors//     /**     * Constructs a <code>DefaultCellEditor</code> that uses a text field.     *     * @param textField  a <code>JTextField</code> object     */    @ConstructorProperties({"component"})    public DefaultCellEditor(final JTextField textField) {        editorComponent = textField;        this.clickCountToStart = 2;        delegate = new EditorDelegate() {            public void setValue(Object value) {                textField.setText((value != null) ? value.toString() : "");            }             public Object getCellEditorValue() {                return textField.getText();            }        };        textField.addActionListener(delegate);    }     /**     * Constructs a <code>DefaultCellEditor</code> object that uses a check box.     *     * @param checkBox  a <code>JCheckBox</code> object     */    public DefaultCellEditor(final JCheckBox checkBox) {        editorComponent = checkBox;        delegate = new EditorDelegate() {            public void setValue(Object value) {                boolean selected = false;                if (value instanceof Boolean) {                    selected = ((Boolean)value).booleanValue();                }                else if (value instanceof String) {                    selected = value.equals("true");                }                checkBox.setSelected(selected);            }             public Object getCellEditorValue() {                return Boolean.valueOf(checkBox.isSelected());            }        };        checkBox.addActionListener(delegate);        checkBox.setRequestFocusEnabled(false);    }     /**     * Constructs a <code>DefaultCellEditor</code> object that uses a     * combo box.     *     * @param comboBox  a <code>JComboBox</code> object     */    public DefaultCellEditor(final JComboBox comboBox) {        editorComponent = comboBox;        comboBox.putClientProperty("JComboBox.isTableCellEditor", Boolean.TRUE);        delegate = new EditorDelegate() {            public void setValue(Object value) {                comboBox.setSelectedItem(value);            }             public Object getCellEditorValue() {                return comboBox.getSelectedItem();            }             public boolean shouldSelectCell(EventObject anEvent) {                if (anEvent instanceof MouseEvent) {                    MouseEvent e = (MouseEvent)anEvent;                    return e.getID() != MouseEvent.MOUSE_DRAGGED;                }                return true;            }            public boolean stopCellEditing() {                if (comboBox.isEditable()) {                    // Commit edited value.                    comboBox.actionPerformed(new ActionEvent(                                     DefaultCellEditor.this, 0, ""));                }                return super.stopCellEditing();            }        };        comboBox.addActionListener(delegate);    }     /**     * Returns a reference to the editor component.     *     * @return the editor <code>Component</code>     */    public Component getComponent() {        return editorComponent;    } ////  Modifying//     /**     * Specifies the number of clicks needed to start editing.     *     * @param count  an int specifying the number of clicks needed to start editing     * @see #getClickCountToStart     */    public void setClickCountToStart(int count) {        clickCountToStart = count;    }     /**     * Returns the number of clicks needed to start editing.     * @return the number of clicks needed to start editing     */    public int getClickCountToStart() {        return clickCountToStart;    } ////  Override the implementations of the superclass, forwarding all methods//  from the CellEditor interface to our delegate.//     /**     * Forwards the message from the <code>CellEditor</code> to     * the <code>delegate</code>.     * @see EditorDelegate#getCellEditorValue     */    public Object getCellEditorValue() {        return delegate.getCellEditorValue();    }     /**     * Forwards the message from the <code>CellEditor</code> to     * the <code>delegate</code>.     * @see EditorDelegate#isCellEditable(EventObject)     */    public boolean isCellEditable(EventObject anEvent) {        return delegate.isCellEditable(anEvent);    }     /**     * Forwards the message from the <code>CellEditor</code> to     * the <code>delegate</code>.     * @see EditorDelegate#shouldSelectCell(EventObject)     */    public boolean shouldSelectCell(EventObject anEvent) {        return delegate.shouldSelectCell(anEvent);    }     /**     * Forwards the message from the <code>CellEditor</code> to     * the <code>delegate</code>.     * @see EditorDelegate#stopCellEditing     */    public boolean stopCellEditing() {        return delegate.stopCellEditing();    }     /**     * Forwards the message from the <code>CellEditor</code> to     * the <code>delegate</code>.     * @see EditorDelegate#cancelCellEditing     */    public void cancelCellEditing() {        delegate.cancelCellEditing();    } ////  Implementing the TreeCellEditor Interface//     /** Implements the <code>TreeCellEditor</code> interface. */    public Component getTreeCellEditorComponent(JTree tree, Object value,                                                boolean isSelected,                                                boolean expanded,                                                boolean leaf, int row) {        String         stringValue = tree.convertValueToText(value, isSelected,                                            expanded, leaf, row, false);         delegate.setValue(stringValue);        return editorComponent;    } ////  Implementing the CellEditor Interface//    /** Implements the <code>TableCellEditor</code> interface. */    public Component getTableCellEditorComponent(JTable table, Object value,                                                 boolean isSelected,                                                 int row, int column) {        delegate.setValue(value);        if (editorComponent instanceof JCheckBox) {            //in order to avoid a "flashing" effect when clicking a checkbox            //in a table, it is important for the editor to have as a border            //the same border that the renderer has, and have as the background            //the same color as the renderer has. This is primarily only            //needed for JCheckBox since this editor doesn't fill all the            //visual space of the table cell, unlike a text field.            TableCellRenderer renderer = table.getCellRenderer(row, column);            Component c = renderer.getTableCellRendererComponent(table, value,                    isSelected, true, row, column);            if (c != null) {                editorComponent.setOpaque(true);                editorComponent.setBackground(c.getBackground());                if (c instanceof JComponent) {                    editorComponent.setBorder(((JComponent)c).getBorder());                }            } else {                editorComponent.setOpaque(false);            }        }        return editorComponent;    }  ////  Protected EditorDelegate class//     /**     * The protected <code>EditorDelegate</code> class.     */    protected class EditorDelegate implements ActionListener, ItemListener, Serializable {         /**  The value of this cell. */        protected Object value;        /**        * Returns the value of this cell.        * @return the value of this cell        */        public Object getCellEditorValue() {            return value;        }        /**        * Sets the value of this cell.        * @param value the new value of this cell        */        public void setValue(Object value) {            this.value = value;        }        /**        * Returns true if <code>anEvent</code> is <b>not</b> a        * <code>MouseEvent</code>.  Otherwise, it returns true        * if the necessary number of clicks have occurred, and        * returns false otherwise.        *        * @param   anEvent         the event        * @return  true  if cell is ready for editing, false otherwise        * @see #setClickCountToStart        * @see #shouldSelectCell        */        public boolean isCellEditable(EventObject anEvent) {            if (anEvent instanceof MouseEvent) {                return ((MouseEvent)anEvent).getClickCount() >= clickCountToStart;            }            return true;        }        /**        * Returns true to indicate that the editing cell may        * be selected.        *        * @param   anEvent         the event        * @return  true        * @see #isCellEditable        */        public boolean shouldSelectCell(EventObject anEvent) {            return true;        }        /**        * Returns true to indicate that editing has begun.        *        * @param anEvent          the event        */        public boolean startCellEditing(EventObject anEvent) {            return true;        }        /**        * Stops editing and        * returns true to indicate that editing has stopped.        * This method calls <code>fireEditingStopped</code>.        *        * @return  true        */        public boolean stopCellEditing() {            fireEditingStopped();            return true;        }        /**        * Cancels editing.  This method calls <code>fireEditingCanceled</code>.        */       public void cancelCellEditing() {           fireEditingCanceled();       }        /**        * When an action is performed, editing is ended.        * @param e the action event        * @see #stopCellEditing        */        public void actionPerformed(ActionEvent e) {            DefaultCellEditor.this.stopCellEditing();        }        /**        * When an item's state changes, editing is ended.        * @param e the action event        * @see #stopCellEditing        */        public void itemStateChanged(ItemEvent e) {            DefaultCellEditor.this.stopCellEditing();        }    } } // End of class JCellEditor