/*

 * Copyright (c) 2011, 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.

 */

/*

 * Copy of javax.swing.plaf.basic.BasicTabbedPaneUI because the original

 * does not have enough private methods marked as protected.

 *

 * This copy is from 1.6.0_04 as of 2008-02-02.

 */

package com.apple.laf;

import java.awt.*;

import java.awt.event.*;

import java.beans.*;

import java.lang.reflect.InvocationTargetException;

import java.util.*;

import javax.swing.*;

import javax.swing.event.*;

import javax.swing.plaf.*;

import javax.swing.plaf.basic.*;

import javax.swing.text.View;

import sun.swing.*;

public class AquaTabbedPaneCopyFromBasicUI 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 final Insets currentPadInsets = new Insets(0, 0, 0, 0);

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

    private Component visibleComponent;

    // PENDING(api): See comment for ContainerHandler

    private Vector<View> htmlViews;

    private Hashtable<Integer, Integer> mnemonicToIndexMap;

    /**

     * 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(final JComponent c) {

        return new AquaTabbedPaneCopyFromBasicUI();

    }

    // MACOSX adding accessor for superclass

    protected Component getTabComponentAt(final int i) {

        return tabPane.getTabComponentAt(i);

    }

    // END MACOSX

    static void loadActionMap(final 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(final JComponent c) {

        this.tabPane = (JTabbedPane)c;

        calculatedBaseline = false;

        rolloverTabIndex = -1;

        focusIndex = -1;

        c.setLayout(createLayoutManager());

        installComponents();

        installDefaults();

        installListeners();

        installKeyboardActions();

    }

    public void uninstallUI(final 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.

     */

    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++) {

            final 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(final 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, AquaTabbedPaneCopyFromBasicUI.class, "TabbedPane.actionMap");

        updateMnemonics();

    }

    InputMap getInputMap(final 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--) {

            final 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();

            mnemonicInputMap.clear();

        }

    }

    /**

     * Adds the specified mnemonic at the specified index.

     */

    private void addMnemonic(final int index, final int mnemonic) {

        if (mnemonicToIndexMap == null) {

            initMnemonics();

        }

        // [2165820] Mac OS X change: mnemonics need to be triggered with ctrl-option, not just option.

        mnemonicInputMap.put(KeyStroke.getKeyStroke(mnemonic, Event.ALT_MASK | Event.CTRL_MASK), "setSelectedIndex");

        mnemonicToIndexMap.put(new Integer(mnemonic), new Integer(index));

    }

    /**

     * Installs the state needed for mnemonics.