DefaultCellEditor.java

/*
 * Copyright (c) 1997, 2020, 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.
 */

packagejavax.swing;

importjava.awt.Component;
importjava.awt.event.*;
importjava.beans.ConstructorProperties;
importjava.lang.Boolean;
importjavax.swing.table.*;
importjavax.swing.event.*;
importjava.util.EventObject;
importjavax.swing.tree.*;
importjava.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
 * has been added to the <code>java.beans</code> package.
 * Please see {@link java.beans.XMLEncoder}.
 *
 * @author Alan Chung
 * @author Philip Milne
 * @since 1.2
 */
@SuppressWarnings("serial") // Same-version serialization only
publicclassDefaultCellEditorextendsAbstractCellEditor
implementsTableCellEditor, TreeCellEditor {

//
// Instance Variables
//

/** The Swing component being edited. */
protectedJComponenteditorComponent;
/**
 * The delegate class which handles all methods sent from the
 * <code>CellEditor</code>.
 */
protectedEditorDelegatedelegate;
/**
 * 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.
 */
protectedintclickCountToStart = 1;

//
// Constructors
//

/**
 * Constructs a <code>DefaultCellEditor</code> that uses a text field.
 *
 * @param textField a <code>JTextField</code> object
 */
@ConstructorProperties({"component"})
publicDefaultCellEditor(finalJTextFieldtextField) {
editorComponent = textField;
this.clickCountToStart = 2;
delegate = newEditorDelegate() {
publicvoidsetValue(Objectvalue) {
textField.setText((value != null) ? value.toString() : "");
 }

publicObjectgetCellEditorValue() {
returntextField.getText();
 }
 };
textField.addActionListener(delegate);
 }

/**
 * Constructs a <code>DefaultCellEditor</code> object that uses a check box.
 *
 * @param checkBox a <code>JCheckBox</code> object
 */
publicDefaultCellEditor(finalJCheckBoxcheckBox) {
editorComponent = checkBox;
delegate = newEditorDelegate() {
publicvoidsetValue(Objectvalue) {
booleanselected = false;
if (valueinstanceofBoolean) {
selected = ((Boolean)value).booleanValue();
 }
elseif (valueinstanceofString) {
selected = value.equals("true");
 }
checkBox.setSelected(selected);
 }

publicObjectgetCellEditorValue() {
returnBoolean.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
 */
publicDefaultCellEditor(finalJComboBox<?> comboBox) {
editorComponent = comboBox;
comboBox.putClientProperty("JComboBox.isTableCellEditor", Boolean.TRUE);
delegate = newEditorDelegate() {
publicvoidsetValue(Objectvalue) {
comboBox.setSelectedItem(value);
 }

publicObjectgetCellEditorValue() {
returncomboBox.getSelectedItem();
 }

publicbooleanshouldSelectCell(EventObjectanEvent) {
if (anEventinstanceofMouseEvent) {
MouseEvente = (MouseEvent)anEvent;
returne.getID() != MouseEvent.MOUSE_DRAGGED;
 }
returntrue;
 }
publicbooleanstopCellEditing() {
if (comboBox.isEditable()) {
// Commit edited value.
comboBox.actionPerformed(newActionEvent(
DefaultCellEditor.this, 0, ""));
 }
returnsuper.stopCellEditing();
 }
 };
comboBox.addActionListener(delegate);
 }

/**
 * Returns a reference to the editor component.
 *
 * @return the editor <code>Component</code>
 */
publicComponentgetComponent() {
returneditorComponent;
 }

//
// 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
 */
publicvoidsetClickCountToStart(intcount) {
clickCountToStart = count;
 }

/**
 * Returns the number of clicks needed to start editing.
 * @return the number of clicks needed to start editing
 */
publicintgetClickCountToStart() {
returnclickCountToStart;
 }

//
// 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
 */
publicObjectgetCellEditorValue() {
returndelegate.getCellEditorValue();
 }

/**
 * Forwards the message from the <code>CellEditor</code> to
 * the <code>delegate</code>.
 * @see EditorDelegate#isCellEditable(EventObject)
 */
publicbooleanisCellEditable(EventObjectanEvent) {
returndelegate.isCellEditable(anEvent);
 }

/**
 * Forwards the message from the <code>CellEditor</code> to
 * the <code>delegate</code>.
 * @see EditorDelegate#shouldSelectCell(EventObject)
 */
publicbooleanshouldSelectCell(EventObjectanEvent) {
returndelegate.shouldSelectCell(anEvent);
 }

/**
 * Forwards the message from the <code>CellEditor</code> to
 * the <code>delegate</code>.
 * @see EditorDelegate#stopCellEditing
 */
publicbooleanstopCellEditing() {
returndelegate.stopCellEditing();
 }

/**
 * Forwards the message from the <code>CellEditor</code> to
 * the <code>delegate</code>.
 * @see EditorDelegate#cancelCellEditing
 */
publicvoidcancelCellEditing() {
delegate.cancelCellEditing();
 }

//
// Implementing the TreeCellEditor Interface
//

/** Implements the <code>TreeCellEditor</code> interface. */
publicComponentgetTreeCellEditorComponent(JTreetree, Objectvalue,
booleanisSelected,
booleanexpanded,
booleanleaf, introw) {
StringstringValue = tree.convertValueToText(value, isSelected,
expanded, leaf, row, false);

delegate.setValue(stringValue);
returneditorComponent;
 }

//
// Implementing the CellEditor Interface
//
/** Implements the <code>TableCellEditor</code> interface. */
publicComponentgetTableCellEditorComponent(JTabletable, Objectvalue,
booleanisSelected,
introw, intcolumn) {
delegate.setValue(value);
if (editorComponentinstanceofJCheckBox) {
//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.
TableCellRendererrenderer = table.getCellRenderer(row, column);
Componentc = renderer.getTableCellRendererComponent(table, value,
isSelected, true, row, column);
if (c != null) {
editorComponent.setOpaque(true);
editorComponent.setBackground(c.getBackground());
if (cinstanceofJComponent) {
editorComponent.setBorder(((JComponent)c).getBorder());
 }
 } else {
editorComponent.setOpaque(false);
 }
 }
returneditorComponent;
 }


//
// Protected EditorDelegate class
//

/**
 * The protected <code>EditorDelegate</code> class.
 */
protectedclassEditorDelegateimplementsActionListener, ItemListener, Serializable {

/** The value of this cell. */
protectedObjectvalue;

/**
 * Constructs an {@code EditorDelegate}.
 */
protectedEditorDelegate() {}

/**
 * Returns the value of this cell.
 * @return the value of this cell
 */
publicObjectgetCellEditorValue() {
returnvalue;
 }

/**
 * Sets the value of this cell.
 * @param value the new value of this cell
 */
publicvoidsetValue(Objectvalue) {
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
 */
publicbooleanisCellEditable(EventObjectanEvent) {
if (anEventinstanceofMouseEvent) {
return ((MouseEvent)anEvent).getClickCount() >= clickCountToStart;
 }
returntrue;
 }

/**
 * Returns true to indicate that the editing cell may
 * be selected.
 *
 * @param anEvent the event
 * @return true
 * @see #isCellEditable
 */
publicbooleanshouldSelectCell(EventObjectanEvent) {
returntrue;
 }

/**
 * Returns true to indicate that editing has begun.
 *
 * @param anEvent the event
 * @return true to indicate editing has begun
 */
publicbooleanstartCellEditing(EventObjectanEvent) {
returntrue;
 }

/**
 * Stops editing and
 * returns true to indicate that editing has stopped.
 * This method calls <code>fireEditingStopped</code>.
 *
 * @return true
 */
publicbooleanstopCellEditing() {
fireEditingStopped();
returntrue;
 }

/**
 * Cancels editing. This method calls <code>fireEditingCanceled</code>.
 */
publicvoidcancelCellEditing() {
fireEditingCanceled();
 }

/**
 * When an action is performed, editing is ended.
 * @param e the action event
 * @see #stopCellEditing
 */
publicvoidactionPerformed(ActionEvente) {
DefaultCellEditor.this.stopCellEditing();
 }

/**
 * When an item's state changes, editing is ended.
 * @param e the action event
 * @see #stopCellEditing
 */
publicvoiditemStateChanged(ItemEvente) {
DefaultCellEditor.this.stopCellEditing();
 }
 }

} // End of class JCellEditor