/*

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

import java.awt.event.*;

import java.util.Vector;

import java.util.Locale;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import java.beans.JavaBean;

import java.beans.BeanProperty;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.beans.Transient;

import javax.swing.event.*;

import javax.accessibility.*;

import javax.swing.plaf.*;

import javax.swing.text.Position;

import java.io.ObjectOutputStream;

import java.io.IOException;

import java.io.Serializable;

import sun.awt.AWTAccessor;

import sun.awt.AWTAccessor.MouseEventAccessor;

import sun.swing.SwingUtilities2;

import sun.swing.SwingUtilities2.Section;

import static sun.swing.SwingUtilities2.Section.*;

/**

 * A component that displays a list of objects and allows the user to select

 * one or more items. A separate model, {@code ListModel}, maintains the

 * contents of the list.

 * <p>

 * It's easy to display an array or Vector of objects, using the {@code JList}

 * constructor that automatically builds a read-only {@code ListModel} instance

 * for you:

 * <pre>

 * {@code

 * // Create a JList that displays strings from an array

 *

 * String[] data = {"one", "two", "three", "four"};

 * JList<String> myList = new JList<String>(data);

 *

 * // Create a JList that displays the superclasses of JList.class, by

 * // creating it with a Vector populated with this data

 *

 * Vector<Class<?>> superClasses = new Vector<Class<?>>();

 * Class<JList> rootClass = javax.swing.JList.class;

 * for(Class<?> cls = rootClass; cls != null; cls = cls.getSuperclass()) {

 *     superClasses.addElement(cls);

 * }

 * JList<Class<?>> myList = new JList<Class<?>>(superClasses);

 *

 * // The automatically created model is stored in JList's "model"

 * // property, which you can retrieve

 *

 * ListModel<Class<?>> model = myList.getModel();

 * for(int i = 0; i < model.getSize(); i++) {

 *     System.out.println(model.getElementAt(i));

 * }

 * }

 * </pre>

 * <p>

 * A {@code ListModel} can be supplied directly to a {@code JList} by way of a

 * constructor or the {@code setModel} method. The contents need not be static -

 * the number of items, and the values of items can change over time. A correct

 * {@code ListModel} implementation notifies the set of

 * {@code javax.swing.event.ListDataListener}s that have been added to it, each

 * time a change occurs. These changes are characterized by a

 * {@code javax.swing.event.ListDataEvent}, which identifies the range of list

 * indices that have been modified, added, or removed. {@code JList}'s

 * {@code ListUI} is responsible for keeping the visual representation up to

 * date with changes, by listening to the model.

 * <p>

 * Simple, dynamic-content, {@code JList} applications can use the

 * {@code DefaultListModel} class to maintain list elements. This class

 * implements the {@code ListModel} interface and also provides a

 * <code>java.util.Vector</code>-like API. Applications that need a more

 * custom <code>ListModel</code> implementation may instead wish to subclass

 * {@code AbstractListModel}, which provides basic support for managing and

 * notifying listeners. For example, a read-only implementation of

 * {@code AbstractListModel}:

 * <pre>

 * {@code

 * // This list model has about 2^16 elements.  Enjoy scrolling.

 *

 * ListModel<String> bigData = new AbstractListModel<String>() {

 *     public int getSize() { return Short.MAX_VALUE; }

 *     public String getElementAt(int index) { return "Index " + index; }

 * };

 * }

 * </pre>

 * <p>

 * The selection state of a {@code JList} is managed by another separate

 * model, an instance of {@code ListSelectionModel}. {@code JList} is

 * initialized with a selection model on construction, and also contains

 * methods to query or set this selection model. Additionally, {@code JList}

 * provides convenient methods for easily managing the selection. These methods,

 * such as {@code setSelectedIndex} and {@code getSelectedValue}, are cover

 * methods that take care of the details of interacting with the selection

 * model. By default, {@code JList}'s selection model is configured to allow any

 * combination of items to be selected at a time; selection mode

 * {@code MULTIPLE_INTERVAL_SELECTION}. The selection mode can be changed

 * on the selection model directly, or via {@code JList}'s cover method.

 * Responsibility for updating the selection model in response to user gestures

 * lies with the list's {@code ListUI}.

 * <p>

 * A correct {@code ListSelectionModel} implementation notifies the set of

 * {@code javax.swing.event.ListSelectionListener}s that have been added to it

 * each time a change to the selection occurs. These changes are characterized

 * by a {@code javax.swing.event.ListSelectionEvent}, which identifies the range

 * of the selection change.

 * <p>

 * The preferred way to listen for changes in list selection is to add

 * {@code ListSelectionListener}s directly to the {@code JList}. {@code JList}

 * then takes care of listening to the selection model and notifying your

 * listeners of change.

 * <p>

 * Responsibility for listening to selection changes in order to keep the list's

 * visual representation up to date lies with the list's {@code ListUI}.

 * <p>

 * <a id="renderer"></a>

 * Painting of cells in a {@code JList} is handled by a delegate called a

 * cell renderer, installed on the list as the {@code cellRenderer} property.

 * The renderer provides a {@code java.awt.Component} that is used

 * like a "rubber stamp" to paint the cells. Each time a cell needs to be

 * painted, the list's {@code ListUI} asks the cell renderer for the component,

 * moves it into place, and has it paint the contents of the cell by way of its

 * {@code paint} method. A default cell renderer, which uses a {@code JLabel}

 * component to render, is installed by the lists's {@code ListUI}. You can

 * substitute your own renderer using code like this:

 * <pre>

 * {@code

 *  // Display an icon and a string for each object in the list.

 *

 * class MyCellRenderer extends JLabel implements ListCellRenderer<Object> {

 *     static final ImageIcon longIcon = new ImageIcon("long.gif");

 *     static final ImageIcon shortIcon = new ImageIcon("short.gif");

 *

 *     // This is the only method defined by ListCellRenderer.

 *     // We just reconfigure the JLabel each time we're called.

 *

 *     public Component getListCellRendererComponent(

 *       JList<?> list,           // the list

 *       Object value,            // value to display

 *       int index,               // cell index

 *       boolean isSelected,      // is the cell selected

 *       boolean cellHasFocus)    // does the cell have focus

 *     {

 *         String s = value.toString();

 *         setText(s);

 *         setIcon((s.length() > 10) ? longIcon : shortIcon);

 *         if (isSelected) {

 *             setBackground(list.getSelectionBackground());

 *             setForeground(list.getSelectionForeground());

 *         } else {

 *             setBackground(list.getBackground());

 *             setForeground(list.getForeground());

 *         }

 *         setEnabled(list.isEnabled());

 *         setFont(list.getFont());

 *         setOpaque(true);

 *         return this;

 *     }

 * }

 *

 * myList.setCellRenderer(new MyCellRenderer());

 * }

 * </pre>

 * <p>

 * Another job for the cell renderer is in helping to determine sizing

 * information for the list. By default, the list's {@code ListUI} determines

 * the size of cells by asking the cell renderer for its preferred

 * size for each list item. This can be expensive for large lists of items.

 * To avoid these calculations, you can set a {@code fixedCellWidth} and

 * {@code fixedCellHeight} on the list, or have these values calculated

 * automatically based on a single prototype value:

 * <a id="prototype_example"></a>

 * <pre>

 * {@code

 * JList<String> bigDataList = new JList<String>(bigData);

 *

 * // We don't want the JList implementation to compute the width

 * // or height of all of the list cells, so we give it a string

 * // that's as big as we'll need for any cell.  It uses this to

 * // compute values for the fixedCellWidth and fixedCellHeight

 * // properties.

 *

 * bigDataList.setPrototypeCellValue("Index 1234567890");

 * }

 * </pre>

 * <p>

 * {@code JList} doesn't implement scrolling directly. To create a list that

 * scrolls, make it the viewport view of a {@code JScrollPane}. For example:

 * <pre>

 * JScrollPane scrollPane = new JScrollPane(myList);

 *

 * // Or in two steps:

 * JScrollPane scrollPane = new JScrollPane();

 * scrollPane.getViewport().setView(myList);

 * </pre>

 * <p>

 * {@code JList} doesn't provide any special handling of double or triple

 * (or N) mouse clicks, but it's easy to add a {@code MouseListener} if you

 * wish to take action on these events. Use the {@code locationToIndex}

 * method to determine what cell was clicked. For example:

 * <pre>

 * MouseListener mouseListener = new MouseAdapter() {

 *     public void mouseClicked(MouseEvent e) {

 *         if (e.getClickCount() == 2) {

 *             int index = list.locationToIndex(e.getPoint());

 *             System.out.println("Double clicked on Item " + index);

 *          }

 *     }

 * };

 * list.addMouseListener(mouseListener);

 * </pre>

 * <p>

 * <strong>Warning:</strong> Swing is not thread safe. For more

 * information see <a

 * href="package-summary.html#threading">Swing's Threading

 * Policy</a>.

 * <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}.

 * <p>

 * for further documentation.

 *

 * @see ListModel

 * @see AbstractListModel

 * @see DefaultListModel

 * @see ListSelectionModel

 * @see DefaultListSelectionModel

 * @see ListCellRenderer

 * @see DefaultListCellRenderer

 *

 * @param <E> the type of the elements of this list

 *

 * @author Hans Muller

 * @since 1.2

 */

@JavaBean(defaultProperty = "UI", description = "A component which allows for the selection of one or more objects from a list.")

@SwingContainer(false)

@SuppressWarnings("serial") // Same-version serialization only

public class JList<E> extends JComponent implements Scrollable, Accessible

{

    /**

     * @see #getUIClassID

     * @see #readObject

     */

    private static final String uiClassID = "ListUI";

    /**

     * Indicates a vertical layout of cells, in a single column;

     * the default layout.

     * @see #setLayoutOrientation

     * @since 1.4

     */

    public static final int VERTICAL = 0;

    /**

     * Indicates a "newspaper style" layout with cells flowing vertically

     * then horizontally.

     * @see #setLayoutOrientation

     * @since 1.4

     */

    public static final int VERTICAL_WRAP = 1;

    /**

     * Indicates a "newspaper style" layout with cells flowing horizontally

     * then vertically.

     * @see #setLayoutOrientation

     * @since 1.4

     */

    public static final int HORIZONTAL_WRAP = 2;

    private int fixedCellWidth = -1;

    private int fixedCellHeight = -1;

    private int horizontalScrollIncrement = -1;

    private E prototypeCellValue;

    private int visibleRowCount = 8;

    private Color selectionForeground;

    private Color selectionBackground;

    private boolean dragEnabled;

    private ListSelectionModel selectionModel;

    private ListModel<E> dataModel;

    private ListCellRenderer<? super E> cellRenderer;

    private ListSelectionListener selectionListener;

    /**

     * How to lay out the cells; defaults to <code>VERTICAL</code>.

     */

    private int layoutOrientation;

    /**

     * The drop mode for this component.

     */

    private DropMode dropMode = DropMode.USE_SELECTION;

    /**

     * The drop location.

     */

    private transient DropLocation dropLocation;

    /**

     * Flag to indicate UI update is in progress

     */

    private transient boolean updateInProgress;

    /**

     * A subclass of <code>TransferHandler.DropLocation</code> representing

     * a drop location for a <code>JList</code>.

     *

     * @see #getDropLocation

     * @since 1.6

     */

    public static final class DropLocation extends TransferHandler.DropLocation {

        private final int index;

        private final boolean isInsert;

        private DropLocation(Point p, int index, boolean isInsert) {

            super(p);

            this.index = index;

            this.isInsert = isInsert;

        }

        /**

         * Returns the index where dropped data should be placed in the

         * list. Interpretation of the value depends on the drop mode set on

         * the associated component. If the drop mode is either

         * <code>DropMode.USE_SELECTION</code> or <code>DropMode.ON</code>,

         * the return value is an index of a row in the list. If the drop mode is

         * <code>DropMode.INSERT</code>, the return value refers to the index

         * where the data should be inserted. If the drop mode is

         * <code>DropMode.ON_OR_INSERT</code>, the value of

         * <code>isInsert()</code> indicates whether the index is an index

         * of a row, or an insert index.

         * <p>

         * <code>-1</code> indicates that the drop occurred over empty space,

         * and no index could be calculated.

         *

         * @return the drop index

         */

        public int getIndex() {

            return index;

        }

        /**

         * Returns whether or not this location represents an insert

         * location.

         *

         * @return whether or not this is an insert location

         */

        public boolean isInsert() {

            return isInsert;

        }

        /**

         * Returns a string representation of this drop location.

         * This method is intended to be used for debugging purposes,

         * and the content and format of the returned string may vary

         * between implementations.

         *

         * @return a string representation of this drop location

         */

        public String toString() {

            return getClass().getName()

                   + "[dropPoint=" + getDropPoint() + ","

                   + "index=" + index + ","

                   + "insert=" + isInsert + "]";

        }

    }

    /**

     * Constructs a {@code JList} that displays elements from the specified,

     * {@code non-null}, model. All {@code JList} constructors delegate to

     * this one.

     * <p>

     * This constructor registers the list with the {@code ToolTipManager},

     * allowing for tooltips to be provided by the cell renderers.

     *

     * @param dataModel the model for the list

     * @exception IllegalArgumentException if the model is {@code null}

     */

    public JList(ListModel<E> dataModel)

    {

        if (dataModel == null) {

            throw new IllegalArgumentException("dataModel must be non null");

        }

        // Register with the ToolTipManager so that tooltips from the

        // renderer show through.

        ToolTipManager toolTipManager = ToolTipManager.sharedInstance();

        toolTipManager.registerComponent(this);

        layoutOrientation = VERTICAL;

        this.dataModel = dataModel;

        selectionModel = createSelectionModel();

        setAutoscrolls(true);

        setOpaque(true);

        updateUI();

    }

    /**

     * Constructs a <code>JList</code> that displays the elements in

     * the specified array. This constructor creates a read-only model

     * for the given array, and then delegates to the constructor that

     * takes a {@code ListModel}.

     * <p>

     * Attempts to pass a {@code null} value to this method results in

     * undefined behavior and, most likely, exceptions. The created model

     * references the given array directly. Attempts to modify the array

     * after constructing the list results in undefined behavior.

     *

     * @param  listData  the array of Objects to be loaded into the data model,

     *                   {@code non-null}

     */

    public JList(final E[] listData)

    {

        this (

            new AbstractListModel<E>() {

                public int getSize() { return listData.length; }

                public E getElementAt(int i) { return listData[i]; }

            }

        );

    }

    /**

     * Constructs a <code>JList</code> that displays the elements in

     * the specified <code>Vector</code>. This constructor creates a read-only

     * model for the given {@code Vector}, and then delegates to the constructor

     * that takes a {@code ListModel}.

     * <p>

     * Attempts to pass a {@code null} value to this method results in

     * undefined behavior and, most likely, exceptions. The created model

     * references the given {@code Vector} directly. Attempts to modify the

     * {@code Vector} after constructing the list results in undefined behavior.

     *

     * @param  listData  the <code>Vector</code> to be loaded into the

     *                   data model, {@code non-null}

     */

    public JList(final Vector<? extends E> listData) {

        this (

            new AbstractListModel<E>() {

                public int getSize() { return listData.size(); }

                public E getElementAt(int i) { return listData.elementAt(i); }

            }

        );

    }

    /**

     * Constructs a <code>JList</code> with an empty, read-only, model.

     */

    public JList() {

        this (

            new AbstractListModel<E>() {

              public int getSize() { return 0; }

              public E getElementAt(int i) { throw new IndexOutOfBoundsException("No Data Model"); }

            }

        );

    }

    /**

     * Returns the {@code ListUI}, the look and feel object that

     * renders this component.

     *

     * @return the <code>ListUI</code> object that renders this component

     */

    public ListUI getUI() {

        return (ListUI)ui;

    }

    /**

     * Sets the {@code ListUI}, the look and feel object that

     * renders this component.