/*

 * Copyright 1997-2007 Sun Microsystems, Inc.  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.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package javax.swing.plaf.basic;

import sun.swing.SwingUtilities2;

import javax.swing.*;

import javax.swing.event.*;

import javax.swing.plaf.*;

import javax.swing.text.View;

import java.awt.*;

import java.awt.event.*;

import java.beans.PropertyChangeListener;

import java.beans.PropertyChangeEvent;

import java.util.Vector;

import java.util.Hashtable;

import sun.swing.DefaultLookup;

import sun.swing.UIAction;

/**

 * A Basic L&F implementation of TabbedPaneUI.

 *

 * @author Amy Fowler

 * @author Philip Milne

 * @author Steve Wilson

 * @author Tom Santos

 * @author Dave Moore

 */

public class BasicTabbedPaneUI extends TabbedPaneUI implements SwingConstants {

// Instance variables initialized at installation

    protected JTabbedPane tabPane;

    protected Color highlight;

    protected Color lightHighlight;

    protected Color shadow;

    protected Color darkShadow;

    protected Color focus;

    private   Color selectedColor;

    protected int textIconGap;

    protected int tabRunOverlay;

    protected Insets tabInsets;

    protected Insets selectedTabPadInsets;

    protected Insets tabAreaInsets;

    protected Insets contentBorderInsets;

    private boolean tabsOverlapBorder;

    private boolean tabsOpaque = true;

    private boolean contentOpaque = true;

    /**

     * As of Java 2 platform v1.3 this previously undocumented field is no

     * longer used.

     * Key bindings are now defined by the LookAndFeel, please refer to

     * the key bindings specification for further details.

     *

     * @deprecated As of Java 2 platform v1.3.

     */

    @Deprecated

    protected KeyStroke upKey;

    /**

     * As of Java 2 platform v1.3 this previously undocumented field is no

     * longer used.

     * Key bindings are now defined by the LookAndFeel, please refer to

     * the key bindings specification for further details.

     *

     * @deprecated As of Java 2 platform v1.3.

     */

    @Deprecated

    protected KeyStroke downKey;

    /**

     * As of Java 2 platform v1.3 this previously undocumented field is no

     * longer used.

     * Key bindings are now defined by the LookAndFeel, please refer to

     * the key bindings specification for further details.

     *

     * @deprecated As of Java 2 platform v1.3.

     */

    @Deprecated

    protected KeyStroke leftKey;

    /**

     * As of Java 2 platform v1.3 this previously undocumented field is no

     * longer used.

     * Key bindings are now defined by the LookAndFeel, please refer to

     * the key bindings specification for further details.

     *

     * @deprecated As of Java 2 platform v1.3.

     */

    @Deprecated

    protected KeyStroke rightKey;

// Transient variables (recalculated each time TabbedPane is layed out)

    protected int tabRuns[] = new int[10];

    protected int runCount = 0;

    protected int selectedRun = -1;

    protected Rectangle rects[] = new Rectangle[0];

    protected int maxTabHeight;

    protected int maxTabWidth;

// Listeners

    protected ChangeListener tabChangeListener;

    protected PropertyChangeListener propertyChangeListener;

    protected MouseListener mouseListener;

    protected FocusListener focusListener;

// Private instance data

    private Insets currentPadInsets = new Insets(0,0,0,0);

    private Insets currentTabAreaInsets = new Insets(0,0,0,0);

    private Component visibleComponent;

    // PENDING(api): See comment for ContainerHandler

    /**

     * InputMap used for mnemonics. Only non-null if the JTabbedPane has

     * mnemonics associated with it. Lazily created in initMnemonics.

     */

    private InputMap mnemonicInputMap;

    // For use when tabLayoutPolicy = SCROLL_TAB_LAYOUT

    private ScrollableTabSupport tabScroller;

    private TabContainer tabContainer;

    /**

     * A rectangle used for general layout calculations in order

     * to avoid constructing many new Rectangles on the fly.

     */

    protected transient Rectangle calcRect = new Rectangle(0,0,0,0);

    /**

     * Tab that has focus.

     */

    private int focusIndex;

    /**

     * Combined listeners.

     */

    private Handler handler;

    /**

     * Index of the tab the mouse is over.

     */

    private int rolloverTabIndex;

    /**

     * This is set to true when a component is added/removed from the tab

     * pane and set to false when layout happens.  If true it indicates that

     * tabRuns is not valid and shouldn't be used.

     */

    private boolean isRunsDirty;

    private boolean calculatedBaseline;

    private int baseline;

// UI creation

    public static ComponentUI createUI(JComponent c) {

        return new BasicTabbedPaneUI();

    }

    static void loadActionMap(LazyActionMap map) {

        map.put(new Actions(Actions.NEXT));

        map.put(new Actions(Actions.PREVIOUS));

        map.put(new Actions(Actions.RIGHT));

        map.put(new Actions(Actions.LEFT));

        map.put(new Actions(Actions.UP));

        map.put(new Actions(Actions.DOWN));

        map.put(new Actions(Actions.PAGE_UP));

        map.put(new Actions(Actions.PAGE_DOWN));

        map.put(new Actions(Actions.REQUEST_FOCUS));

        map.put(new Actions(Actions.REQUEST_FOCUS_FOR_VISIBLE));

        map.put(new Actions(Actions.SET_SELECTED));

        map.put(new Actions(Actions.SELECT_FOCUSED));

        map.put(new Actions(Actions.SCROLL_FORWARD));

        map.put(new Actions(Actions.SCROLL_BACKWARD));

    }

// UI Installation/De-installation

    public void installUI(JComponent c) {

        this.tabPane = (JTabbedPane)c;

        calculatedBaseline = false;

        rolloverTabIndex = -1;

        focusIndex = -1;

        c.setLayout(createLayoutManager());

        installComponents();

        installDefaults();

        installListeners();

        installKeyboardActions();

    }

    public void uninstallUI(JComponent c) {

        uninstallKeyboardActions();

        uninstallListeners();

        uninstallDefaults();

        uninstallComponents();

        c.setLayout(null);

        this.tabPane = null;

    }

    /**

     * Invoked by <code>installUI</code> to create

     * a layout manager object to manage

     * the <code>JTabbedPane</code>.

     *

     * @return a layout manager object

     *

     * @see TabbedPaneLayout

     * @see javax.swing.JTabbedPane#getTabLayoutPolicy

     */

    protected LayoutManager createLayoutManager() {

        if (tabPane.getTabLayoutPolicy() == JTabbedPane.SCROLL_TAB_LAYOUT) {

            return new TabbedPaneScrollLayout();

        } else { /* WRAP_TAB_LAYOUT */

            return new TabbedPaneLayout();

        }

    }

    /* In an attempt to preserve backward compatibility for programs

     * which have extended BasicTabbedPaneUI to do their own layout, the

     * UI uses the installed layoutManager (and not tabLayoutPolicy) to

     * determine if scrollTabLayout is enabled.

     */

    private boolean scrollableTabLayoutEnabled() {

        return (tabPane.getLayout() instanceof TabbedPaneScrollLayout);

    }

    /**

     * Creates and installs any required subcomponents for the JTabbedPane.

     * Invoked by installUI.

     *

     * @since 1.4

     */

    protected void installComponents() {

        if (scrollableTabLayoutEnabled()) {

            if (tabScroller == null) {

                tabScroller = new ScrollableTabSupport(tabPane.getTabPlacement());

                tabPane.add(tabScroller.viewport);

            }

        }

        installTabContainer();

    }

    private void installTabContainer() {

         for (int i = 0; i < tabPane.getTabCount(); i++) {

             Component tabComponent = tabPane.getTabComponentAt(i);

             if (tabComponent != null) {

                 if(tabContainer == null) {

                     tabContainer = new TabContainer();

                 }

                 tabContainer.add(tabComponent);

             }

         }

         if(tabContainer == null) {

             return;

         }

         if (scrollableTabLayoutEnabled()) {

             tabScroller.tabPanel.add(tabContainer);

         } else {

             tabPane.add(tabContainer);

         }

    }

    /**

     * Creates and returns a JButton that will provide the user

     * with a way to scroll the tabs in a particular direction. The

     * returned JButton must be instance of UIResource.

     *

     * @param direction One of the SwingConstants constants:

     * SOUTH, NORTH, EAST or WEST

     * @return Widget for user to

     * @see javax.swing.JTabbedPane#setTabPlacement

     * @see javax.swing.SwingConstants

     * @throws IllegalArgumentException if direction is not one of

     *         NORTH, SOUTH, EAST or WEST

     * @since 1.5

     */

    protected JButton createScrollButton(int direction) {

        if (direction != SOUTH && direction != NORTH && direction != EAST &&

                                  direction != WEST) {

            throw new IllegalArgumentException("Direction must be one of: " +

                                               "SOUTH, NORTH, EAST or WEST");

        }

        return new ScrollableTabButton(direction);

    }

    /**

     * Removes any installed subcomponents from the JTabbedPane.

     * Invoked by uninstallUI.

     *

     * @since 1.4

     */

    protected void uninstallComponents() {

        uninstallTabContainer();

        if (scrollableTabLayoutEnabled()) {

            tabPane.remove(tabScroller.viewport);

            tabPane.remove(tabScroller.scrollForwardButton);

            tabPane.remove(tabScroller.scrollBackwardButton);

            tabScroller = null;

        }

    }

    private void uninstallTabContainer() {

         if(tabContainer == null) {

             return;

         }

         // Remove all the tabComponents, making sure not to notify

         // the tabbedpane.

         tabContainer.notifyTabbedPane = false;

         tabContainer.removeAll();

         if(scrollableTabLayoutEnabled()) {

             tabContainer.remove(tabScroller.croppedEdge);

             tabScroller.tabPanel.remove(tabContainer);

         } else {

           tabPane.remove(tabContainer);

         }

         tabContainer = null;

    }

    protected void installDefaults() {

        LookAndFeel.installColorsAndFont(tabPane, "TabbedPane.background",

                                    "TabbedPane.foreground", "TabbedPane.font");

        highlight = UIManager.getColor("TabbedPane.light");

        lightHighlight = UIManager.getColor("TabbedPane.highlight");

        shadow = UIManager.getColor("TabbedPane.shadow");

        darkShadow = UIManager.getColor("TabbedPane.darkShadow");

        focus = UIManager.getColor("TabbedPane.focus");

        selectedColor = UIManager.getColor("TabbedPane.selected");

        textIconGap = UIManager.getInt("TabbedPane.textIconGap");

        tabInsets = UIManager.getInsets("TabbedPane.tabInsets");

        selectedTabPadInsets = UIManager.getInsets("TabbedPane.selectedTabPadInsets");

        tabAreaInsets = UIManager.getInsets("TabbedPane.tabAreaInsets");

        tabsOverlapBorder = UIManager.getBoolean("TabbedPane.tabsOverlapBorder");

        contentBorderInsets = UIManager.getInsets("TabbedPane.contentBorderInsets");

        tabRunOverlay = UIManager.getInt("TabbedPane.tabRunOverlay");

        tabsOpaque = UIManager.getBoolean("TabbedPane.tabsOpaque");

        contentOpaque = UIManager.getBoolean("TabbedPane.contentOpaque");

        Object opaque = UIManager.get("TabbedPane.opaque");

        if (opaque == null) {

            opaque = Boolean.FALSE;

        }

        LookAndFeel.installProperty(tabPane, "opaque", opaque);

    }

    protected void uninstallDefaults() {

        highlight = null;

        lightHighlight = null;

        shadow = null;

        darkShadow = null;

        focus = null;

        tabInsets = null;

        selectedTabPadInsets = null;

        tabAreaInsets = null;

        contentBorderInsets = null;

    }

    protected void installListeners() {

        if ((propertyChangeListener = createPropertyChangeListener()) != null) {

            tabPane.addPropertyChangeListener(propertyChangeListener);

        }

        if ((tabChangeListener = createChangeListener()) != null) {

            tabPane.addChangeListener(tabChangeListener);

        }

        if ((mouseListener = createMouseListener()) != null) {

            tabPane.addMouseListener(mouseListener);

        }

        tabPane.addMouseMotionListener(getHandler());

        if ((focusListener = createFocusListener()) != null) {

            tabPane.addFocusListener(focusListener);

        }

        tabPane.addContainerListener(getHandler());

        if (tabPane.getTabCount()>0) {

            htmlViews = createHTMLVector();

        }

    }

    protected void uninstallListeners() {

        if (mouseListener != null) {

            tabPane.removeMouseListener(mouseListener);

            mouseListener = null;

        }

        tabPane.removeMouseMotionListener(getHandler());

        if (focusListener != null) {

            tabPane.removeFocusListener(focusListener);

            focusListener = null;

        }

        tabPane.removeContainerListener(getHandler());

        if (htmlViews!=null) {

            htmlViews.removeAllElements();

            htmlViews = null;

        }

        if (tabChangeListener != null) {

            tabPane.removeChangeListener(tabChangeListener);

            tabChangeListener = null;

        }

        if (propertyChangeListener != null) {

            tabPane.removePropertyChangeListener(propertyChangeListener);

            propertyChangeListener = null;

        }

        handler = null;

    }

    protected MouseListener createMouseListener() {

        return getHandler();

    }

    protected FocusListener createFocusListener() {

        return getHandler();

    }

    protected ChangeListener createChangeListener() {

        return getHandler();

    }

    protected PropertyChangeListener createPropertyChangeListener() {

        return getHandler();

    }

    private Handler getHandler() {

        if (handler == null) {

            handler = new Handler();

        }

        return handler;

    }

    protected void installKeyboardActions() {

        InputMap km = getInputMap(JComponent.

                                  WHEN_ANCESTOR_OF_FOCUSED_COMPONENT);

        SwingUtilities.replaceUIInputMap(tabPane, JComponent.

                                         WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,

                                         km);

        km = getInputMap(JComponent.WHEN_FOCUSED);

        SwingUtilities.replaceUIInputMap(tabPane, JComponent.WHEN_FOCUSED, km);

        LazyActionMap.installLazyActionMap(tabPane, BasicTabbedPaneUI.class,

                                           "TabbedPane.actionMap");

        updateMnemonics();

    }

    InputMap getInputMap(int condition) {

        if (condition == JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT) {

            return (InputMap)DefaultLookup.get(tabPane, this,

                                               "TabbedPane.ancestorInputMap");

        }

        else if (condition == JComponent.WHEN_FOCUSED) {

            return (InputMap)DefaultLookup.get(tabPane, this,

                                               "TabbedPane.focusInputMap");

        }

        return null;

    }

    protected void uninstallKeyboardActions() {

        SwingUtilities.replaceUIActionMap(tabPane, null);

        SwingUtilities.replaceUIInputMap(tabPane, JComponent.

                                         WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,

                                         null);

        SwingUtilities.replaceUIInputMap(tabPane, JComponent.WHEN_FOCUSED,

                                         null);

        SwingUtilities.replaceUIInputMap(tabPane,

                                         JComponent.WHEN_IN_FOCUSED_WINDOW,

                                         null);

        mnemonicToIndexMap = null;

        mnemonicInputMap = null;

    }

    /**

     * Reloads the mnemonics. This should be invoked when a memonic changes,

     * when the title of a mnemonic changes, or when tabs are added/removed.

     */

    private void updateMnemonics() {

        resetMnemonics();

        for (int counter = tabPane.getTabCount() - 1; counter >= 0;

             counter--) {

            int mnemonic = tabPane.getMnemonicAt(counter);

            if (mnemonic > 0) {

                addMnemonic(counter, mnemonic);

            }

        }

    }

    /**

     * Resets the mnemonics bindings to an empty state.

     */

    private void resetMnemonics() {

        if (mnemonicToIndexMap != null) {

            mnemonicToIndexMap.clear();