/*

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

import sun.swing.table.DefaultTableCellHeaderRenderer;

import java.util.*;

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

import javax.swing.event.*;

import javax.swing.plaf.*;

import javax.accessibility.*;

import java.beans.PropertyChangeListener;

import java.beans.Transient;

import java.io.ObjectOutputStream;

import java.io.ObjectInputStream;

import java.io.IOException;

/**

 * This is the object which manages the header of the <code>JTable</code>.

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

 * @see javax.swing.JTable

 */

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

public class JTableHeader extends JComponent implements TableColumnModelListener, Accessible

{

    /**

     * @see #getUIClassID

     * @see #readObject

     */

    private static final String uiClassID = "TableHeaderUI";

//

// Instance Variables

//

    /**

     * The table for which this object is the header;

     * the default is <code>null</code>.

     */

    protected JTable table;

    /**

     * The <code>TableColumnModel</code> of the table header.

     */

    protected TableColumnModel  columnModel;

    /**

     * If true, reordering of columns are allowed by the user;

     * the default is true.

     */

    protected boolean   reorderingAllowed;

    /**

     * If true, resizing of columns are allowed by the user;

     * the default is true.

     */

    protected boolean   resizingAllowed;

    /**

     * Obsolete as of Java 2 platform v1.3.  Real time repaints, in response

     * to column dragging or resizing, are now unconditional.

     */

    /*

     * If this flag is true, then the header will repaint the table as

     * a column is dragged or resized; the default is true.

     */

    protected boolean   updateTableInRealTime;

    /** The index of the column being resized. <code>null</code> if not resizing. */

    transient protected TableColumn     resizingColumn;

    /** The index of the column being dragged. <code>null</code> if not dragging. */

    transient protected TableColumn     draggedColumn;

    /** The distance from its original position the column has been dragged. */

    transient protected int     draggedDistance;

    /**

      *  The default renderer to be used when a <code>TableColumn</code>

      *  does not define a <code>headerRenderer</code>.

      */

    private TableCellRenderer defaultRenderer;

//

// Constructors

//

    /**

     *  Constructs a <code>JTableHeader</code> with a default

     *  <code>TableColumnModel</code>.

     *

     * @see #createDefaultColumnModel

     */

    public JTableHeader() {

        this(null);

    }

    /**

     *  Constructs a <code>JTableHeader</code> which is initialized with

     *  <code>cm</code> as the column model.  If <code>cm</code> is

     *  <code>null</code> this method will initialize the table header

     *  with a default <code>TableColumnModel</code>.

     *

     * @param cm        the column model for the table

     * @see #createDefaultColumnModel

     */

    public JTableHeader(TableColumnModel cm) {

        super();

        //setFocusable(false); // for strict win/mac compatibility mode,

                               // this method should be invoked

        if (cm == null)

            cm = createDefaultColumnModel();

        setColumnModel(cm);

        // Initialize local ivars

        initializeLocalVars();

        // Get UI going

        updateUI();

    }

//

// Local behavior attributes

//

    /**

     *  Sets the table associated with this header.

     *  @param  table   the new table

     *  @beaninfo

     *   bound: true

     *   description: The table associated with this header.

     */

    public void setTable(JTable table) {

        JTable old = this.table;

        this.table = table;

        firePropertyChange("table", old, table);

    }

    /**

      *  Returns the table associated with this header.

      *  @return  the <code>table</code> property

      */

    public JTable getTable() {

        return table;

    }

    /**

     *  Sets whether the user can drag column headers to reorder columns.

     *

     * @param   reorderingAllowed       true if the table view should allow

     *                                  reordering; otherwise false

     * @see     #getReorderingAllowed

     * @beaninfo

     *  bound: true

     *  description: Whether the user can drag column headers to reorder columns.

     */

    public void setReorderingAllowed(boolean reorderingAllowed) {

        boolean old = this.reorderingAllowed;

        this.reorderingAllowed = reorderingAllowed;

        firePropertyChange("reorderingAllowed", old, reorderingAllowed);

    }

    /**

     * Returns true if the user is allowed to rearrange columns by

     * dragging their headers, false otherwise. The default is true. You can

     * rearrange columns programmatically regardless of this setting.

     *

     * @return  the <code>reorderingAllowed</code> property

     * @see     #setReorderingAllowed

     */

    public boolean getReorderingAllowed() {

        return reorderingAllowed;

    }

    /**

     *  Sets whether the user can resize columns by dragging between headers.

     *

     * @param   resizingAllowed         true if table view should allow

     *                                  resizing

     * @see     #getResizingAllowed

     * @beaninfo

     *  bound: true

     *  description: Whether the user can resize columns by dragging between headers.

     */

    public void setResizingAllowed(boolean resizingAllowed) {

        boolean old = this.resizingAllowed;

        this.resizingAllowed = resizingAllowed;

        firePropertyChange("resizingAllowed", old, resizingAllowed);

    }

    /**

     * Returns true if the user is allowed to resize columns by dragging

     * between their headers, false otherwise. The default is true. You can

     * resize columns programmatically regardless of this setting.

     *

     * @return  the <code>resizingAllowed</code> property

     * @see     #setResizingAllowed

     */

    public boolean getResizingAllowed() {

        return resizingAllowed;

    }

    /**

     * Returns the the dragged column, if and only if, a drag is in

     * process, otherwise returns <code>null</code>.

     *

     * @return  the dragged column, if a drag is in

     *          process, otherwise returns <code>null</code>

     * @see     #getDraggedDistance

     */

    public TableColumn getDraggedColumn() {

        return draggedColumn;

    }

    /**

     * Returns the column's horizontal distance from its original

     * position, if and only if, a drag is in process. Otherwise, the

     * the return value is meaningless.

     *

     * @return  the column's horizontal distance from its original

     *          position, if a drag is in process, otherwise the return

     *          value is meaningless

     * @see     #getDraggedColumn

     */

    public int getDraggedDistance() {

        return draggedDistance;

    }

    /**

     * Returns the resizing column.  If no column is being

     * resized this method returns <code>null</code>.

     *

     * @return  the resizing column, if a resize is in process, otherwise

     *          returns <code>null</code>

     */

    public TableColumn getResizingColumn() {

        return resizingColumn;

    }

    /**

     * Obsolete as of Java 2 platform v1.3.  Real time repaints, in response to

     * column dragging or resizing, are now unconditional.

     */

    /*

     *  Sets whether the body of the table updates in real time when

     *  a column is resized or dragged.

     *

     * @param   flag                    true if tableView should update

     *                                  the body of the table in real time

     * @see #getUpdateTableInRealTime

     */

    public void setUpdateTableInRealTime(boolean flag) {

        updateTableInRealTime = flag;

    }

    /**

     * Obsolete as of Java 2 platform v1.3.  Real time repaints, in response to

     * column dragging or resizing, are now unconditional.

     */

    /*

     * Returns true if the body of the table view updates in real

     * time when a column is resized or dragged.  User can set this flag to

     * false to speed up the table's response to user resize or drag actions.

     * The default is true.

     *

     * @return  true if the table updates in real time

     * @see #setUpdateTableInRealTime

     */

    public boolean getUpdateTableInRealTime() {

        return updateTableInRealTime;

    }

    /**

     * Sets the default renderer to be used when no <code>headerRenderer</code>

     * is defined by a <code>TableColumn</code>.

     * @param  defaultRenderer  the default renderer

     * @since 1.3

     */

    public void setDefaultRenderer(TableCellRenderer defaultRenderer) {

        this.defaultRenderer = defaultRenderer;

    }

    /**

     * Returns the default renderer used when no <code>headerRenderer</code>

     * is defined by a <code>TableColumn</code>.

     * @return the default renderer

     * @since 1.3

     */

    @Transient

    public TableCellRenderer getDefaultRenderer() {

        return defaultRenderer;

    }

    /**

     * Returns the index of the column that <code>point</code> lies in, or -1 if it

     * lies out of bounds.

     *

     * @return  the index of the column that <code>point</code> lies in, or -1 if it

     *          lies out of bounds

     */

    public int columnAtPoint(Point point) {

        int x = point.x;

        if (!getComponentOrientation().isLeftToRight()) {

            x = getWidthInRightToLeft() - x - 1;

        }

        return getColumnModel().getColumnIndexAtX(x);

    }

    /**

     * Returns the rectangle containing the header tile at <code>column</code>.

     * When the <code>column</code> parameter is out of bounds this method uses the

     * same conventions as the <code>JTable</code> method <code>getCellRect</code>.

     *

     * @return  the rectangle containing the header tile at <code>column</code>

     * @see JTable#getCellRect

     */

    public Rectangle getHeaderRect(int column) {

        Rectangle r = new Rectangle();

        TableColumnModel cm = getColumnModel();

        r.height = getHeight();

        if (column < 0) {

            // x = width = 0;

            if( !getComponentOrientation().isLeftToRight() ) {

                r.x = getWidthInRightToLeft();

            }

        }

        else if (column >= cm.getColumnCount()) {

            if( getComponentOrientation().isLeftToRight() ) {

                r.x = getWidth();

            }

        }

        else {

            for(int i = 0; i < column; i++) {

                r.x += cm.getColumn(i).getWidth();

            }

            if( !getComponentOrientation().isLeftToRight() ) {

                r.x = getWidthInRightToLeft() - r.x - cm.getColumn(column).getWidth();

            }

            r.width = cm.getColumn(column).getWidth();

        }

        return r;

    }

    /**

     * Allows the renderer's tips to be used if there is text set.

     * @param  event  the location of the event identifies the proper

     *                          renderer and, therefore, the proper tip

     * @return the tool tip for this component

     */

    public String getToolTipText(MouseEvent event) {

        String tip = null;

        Point p = event.getPoint();

        int column;

        // Locate the renderer under the event location

        if ((column = columnAtPoint(p)) != -1) {

            TableColumn aColumn = columnModel.getColumn(column);

            TableCellRenderer renderer = aColumn.getHeaderRenderer();

            if (renderer == null) {

                renderer = defaultRenderer;

            }

            Component component = renderer.getTableCellRendererComponent(

                              getTable(), aColumn.getHeaderValue(), false, false,

                              -1, column);

            // Now have to see if the component is a JComponent before

            // getting the tip

            if (component instanceof JComponent) {

                // Convert the event to the renderer's coordinate system

                MouseEvent newEvent;

                Rectangle cellRect = getHeaderRect(column);

                p.translate(-cellRect.x, -cellRect.y);

                newEvent = new MouseEvent(component, event.getID(),

                                          event.getWhen(), event.getModifiers(),

                                          p.x, p.y, event.getXOnScreen(), event.getYOnScreen(),

                                          event.getClickCount(),

                                          event.isPopupTrigger(), MouseEvent.NOBUTTON);

                tip = ((JComponent)component).getToolTipText(newEvent);

            }

        }

        // No tip from the renderer get our own tip

        if (tip == null)

            tip = getToolTipText();

        return tip;

    }

//

// Managing TableHeaderUI

//

    /**

     * Returns the look and feel (L&F) object that renders this component.

     *

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

     */

    public TableHeaderUI getUI() {

        return (TableHeaderUI)ui;

    }

    /**

     * Sets the look and feel (L&F) object that renders this component.

     *

     * @param ui  the <code>TableHeaderUI</code> L&amp;F object

     * @see UIDefaults#getUI

     */

    public void setUI(TableHeaderUI ui){

        if (this.ui != ui) {

            super.setUI(ui);

            repaint();

        }

    }

    /**

     * Notification from the <code>UIManager</code> that the look and feel

     * (L&F) has changed.

     * Replaces the current UI object with the latest version from the

     * <code>UIManager</code>.

     *

     * @see JComponent#updateUI

     */

    public void updateUI(){

        setUI((TableHeaderUI)UIManager.getUI(this));

        TableCellRenderer renderer = getDefaultRenderer();

        if (renderer instanceof Component) {

            SwingUtilities.updateComponentTreeUI((Component)renderer);

        }

    }

    /**

     * Returns the suffix used to construct the name of the look and feel

     * (L&F) class used to render this component.

     * @return the string "TableHeaderUI"

     *

     * @return "TableHeaderUI"

     * @see JComponent#getUIClassID

     * @see UIDefaults#getUI

     */

    public String getUIClassID() {

        return uiClassID;

    }

//

// Managing models

//

    /**

     *  Sets the column model for this table to <code>newModel</code> and registers

     *  for listener notifications from the new column model.

     *

     * @param   columnModel     the new data source for this table

     * @exception IllegalArgumentException

     *                          if <code>newModel</code> is <code>null</code>

     * @see     #getColumnModel

     * @beaninfo

     *  bound: true

     *  description: The object governing the way columns appear in the view.

     */

    public void setColumnModel(TableColumnModel columnModel) {

        if (columnModel == null) {

            throw new IllegalArgumentException("Cannot set a null ColumnModel");

        }

        TableColumnModel old = this.columnModel;

        if (columnModel != old) {

            if (old != null) {

                old.removeColumnModelListener(this);

            }

            this.columnModel = columnModel;

            columnModel.addColumnModelListener(this);

            firePropertyChange("columnModel", old, columnModel);

            resizeAndRepaint();

        }

    }