/*

 * Copyright (c) 2002, 2010, 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.plaf.synth;

import javax.swing.*;

import javax.swing.plaf.*;

import javax.swing.plaf.basic.*;

import javax.swing.text.View;

import java.awt.*;

import java.awt.event.*;

import java.beans.PropertyChangeListener;

import java.beans.PropertyChangeEvent;

import sun.swing.SwingUtilities2;

/**

 * Provides the Synth L&F UI delegate for

 * {@link javax.swing.JTabbedPane}.

 *

 * <p>Looks up the {@code selectedTabPadInsets} property from the Style,

 * which represents additional insets for the selected tab.

 *

 * @author Scott Violet

 * @since 1.7

 */

public class SynthTabbedPaneUI extends BasicTabbedPaneUI

                               implements PropertyChangeListener, SynthUI {

    /**

     * <p>If non-zero, tabOverlap indicates the amount that the tab bounds

     * should be altered such that they would overlap with a tab on either the

     * leading or trailing end of a run (ie: in TOP, this would be on the left

     * or right).</p>

     * <p>A positive overlap indicates that tabs should overlap right/down,

     * while a negative overlap indicates tha tabs should overlap left/up.</p>

     *

     * <p>When tabOverlap is specified, it both changes the x position and width

     * of the tab if in TOP or BOTTOM placement, and changes the y position and

     * height if in LEFT or RIGHT placement.</p>

     *

     * <p>This is done for the following reason. Consider a run of 10 tabs.

     * There are 9 gaps between these tabs. If you specified a tabOverlap of

     * "-1", then each of the tabs "x" values will be shifted left. This leaves

     * 9 pixels of space to the right of the right-most tab unpainted. So, each

     * tab's width is also extended by 1 pixel to make up the difference.</p>

     *

     * <p>This property respects the RTL component orientation.</p>

     */

    private int tabOverlap = 0;

    /**

     * When a tabbed pane has multiple rows of tabs, this indicates whether

     * the tabs in the upper row(s) should extend to the base of the tab area,

     * or whether they should remain at their normal tab height. This does not

     * affect the bounds of the tabs, only the bounds of area painted by the

     * tabs. The text position does not change. The result is that the bottom

     * border of the upper row of tabs becomes fully obscured by the lower tabs,

     * resulting in a cleaner look.

     */

    private boolean extendTabsToBase = false;

    private SynthContext tabAreaContext;

    private SynthContext tabContext;

    private SynthContext tabContentContext;

    private SynthStyle style;

    private SynthStyle tabStyle;

    private SynthStyle tabAreaStyle;

    private SynthStyle tabContentStyle;

    private Rectangle textRect = new Rectangle();

    private Rectangle iconRect = new Rectangle();

    private Rectangle tabAreaBounds = new Rectangle();

    //added for the Nimbus look and feel, where the tab area is painted differently depending on the

    //state for the selected tab

    private boolean tabAreaStatesMatchSelectedTab = false;

    //added for the Nimbus LAF to ensure that the labels don't move whether the tab is selected or not

    private boolean nudgeSelectedLabel = true;

    private boolean selectedTabIsPressed = false;

    /**

     * Creates a new UI object for the given component.

     *

     * @param c component to create UI object for

     * @return the UI object

     */

    public static ComponentUI createUI(JComponent c) {

        return new SynthTabbedPaneUI();

    }

    private boolean scrollableTabLayoutEnabled() {

        return (tabPane.getTabLayoutPolicy() == JTabbedPane.SCROLL_TAB_LAYOUT);

    }

    /**

     * @inheritDoc

     */

    @Override

    protected void installDefaults() {

        updateStyle(tabPane);

    }

    private void updateStyle(JTabbedPane c) {

        SynthContext context = getContext(c, ENABLED);

        SynthStyle oldStyle = style;

        style = SynthLookAndFeel.updateStyle(context, this);

        // Add properties other than JComponent colors, Borders and

        // opacity settings here:

        if (style != oldStyle) {

            tabRunOverlay =

                style.getInt(context, "TabbedPane.tabRunOverlay", 0);

            tabOverlap = style.getInt(context, "TabbedPane.tabOverlap", 0);

            extendTabsToBase = style.getBoolean(context,

                    "TabbedPane.extendTabsToBase", false);

            textIconGap = style.getInt(context, "TabbedPane.textIconGap", 0);

            selectedTabPadInsets = (Insets)style.get(context,

                "TabbedPane.selectedTabPadInsets");

            if (selectedTabPadInsets == null) {

                selectedTabPadInsets = new Insets(0, 0, 0, 0);

            }

            tabAreaStatesMatchSelectedTab = style.getBoolean(context,

                    "TabbedPane.tabAreaStatesMatchSelectedTab", false);

            nudgeSelectedLabel = style.getBoolean(context,

                    "TabbedPane.nudgeSelectedLabel", true);

            if (oldStyle != null) {

                uninstallKeyboardActions();

                installKeyboardActions();

            }

        }

        context.dispose();

        if (tabContext != null) {

            tabContext.dispose();

        }

        tabContext = getContext(c, Region.TABBED_PANE_TAB, ENABLED);

        this.tabStyle = SynthLookAndFeel.updateStyle(tabContext, this);

        tabInsets = tabStyle.getInsets(tabContext, null);

        if (tabAreaContext != null) {

            tabAreaContext.dispose();

        }

        tabAreaContext = getContext(c, Region.TABBED_PANE_TAB_AREA, ENABLED);

        this.tabAreaStyle = SynthLookAndFeel.updateStyle(tabAreaContext, this);

        tabAreaInsets = tabAreaStyle.getInsets(tabAreaContext, null);

        if (tabContentContext != null) {

            tabContentContext.dispose();

        }

        tabContentContext = getContext(c, Region.TABBED_PANE_CONTENT, ENABLED);

        this.tabContentStyle = SynthLookAndFeel.updateStyle(tabContentContext,

                                                            this);

        contentBorderInsets =

            tabContentStyle.getInsets(tabContentContext, null);

    }

    /**

     * @inheritDoc

     */

    @Override

    protected void installListeners() {

        super.installListeners();

        tabPane.addPropertyChangeListener(this);

    }

    /**

     * @inheritDoc

     */

    @Override

    protected void uninstallListeners() {

        super.uninstallListeners();

        tabPane.removePropertyChangeListener(this);

    }

    /**

     * @inheritDoc

     */

    @Override

    protected void uninstallDefaults() {

        SynthContext context = getContext(tabPane, ENABLED);

        style.uninstallDefaults(context);

        context.dispose();

        style = null;

        tabStyle.uninstallDefaults(tabContext);

        tabContext.dispose();

        tabContext = null;

        tabStyle = null;

        tabAreaStyle.uninstallDefaults(tabAreaContext);

        tabAreaContext.dispose();

        tabAreaContext = null;

        tabAreaStyle = null;

        tabContentStyle.uninstallDefaults(tabContentContext);

        tabContentContext.dispose();

        tabContentContext = null;

        tabContentStyle = null;

    }

    /**

     * @inheritDoc

     */

    @Override

    public SynthContext getContext(JComponent c) {

        return getContext(c, SynthLookAndFeel.getComponentState(c));

    }

    private SynthContext getContext(JComponent c, int state) {

        return SynthContext.getContext(SynthContext.class, c,

                    SynthLookAndFeel.getRegion(c),style, state);

    }

    private SynthContext getContext(JComponent c, Region subregion, int state){

        SynthStyle style = null;

        Class klass = SynthContext.class;

        if (subregion == Region.TABBED_PANE_TAB) {

            style = tabStyle;

        }

        else if (subregion == Region.TABBED_PANE_TAB_AREA) {

            style = tabAreaStyle;

        }

        else if (subregion == Region.TABBED_PANE_CONTENT) {

            style = tabContentStyle;

        }

        return SynthContext.getContext(klass, c, subregion, style, state);

    }

    /**

     * @inheritDoc

     */

    @Override

    protected JButton createScrollButton(int direction) {

        // added for Nimbus LAF so that it can use the basic arrow buttons

        // UIManager is queried directly here because this is called before

        // updateStyle is called so the style can not be queried directly

        if (UIManager.getBoolean("TabbedPane.useBasicArrows")) {

            JButton btn = super.createScrollButton(direction);

            btn.setBorder(BorderFactory.createEmptyBorder());

            return btn;

        }

        return new SynthScrollableTabButton(direction);

    }

    /**

     * @inheritDoc

     */

    @Override

    public void propertyChange(PropertyChangeEvent e) {

        if (SynthLookAndFeel.shouldUpdateStyle(e)) {

            updateStyle(tabPane);

        }

    }

    /**

     * @inheritDoc

     *

     * Overridden to keep track of whether the selected tab is also pressed.

     */

    @Override

    protected MouseListener createMouseListener() {

        final MouseListener delegate = super.createMouseListener();

        final MouseMotionListener delegate2 = (MouseMotionListener)delegate;

        return new MouseListener() {

            public void mouseClicked(MouseEvent e) { delegate.mouseClicked(e); }

            public void mouseEntered(MouseEvent e) { delegate.mouseEntered(e); }

            public void mouseExited(MouseEvent e) { delegate.mouseExited(e); }

            public void mousePressed(MouseEvent e) {

                if (!tabPane.isEnabled()) {

                    return;

                }

                int tabIndex = tabForCoordinate(tabPane, e.getX(), e.getY());

                if (tabIndex >= 0 && tabPane.isEnabledAt(tabIndex)) {

                    if (tabIndex == tabPane.getSelectedIndex()) {

                        // Clicking on selected tab

                        selectedTabIsPressed = true;

                        //TODO need to just repaint the tab area!

                        tabPane.repaint();

                    }

                }

                //forward the event (this will set the selected index, or none at all

                delegate.mousePressed(e);

            }

            public void mouseReleased(MouseEvent e) {

                if (selectedTabIsPressed) {

                    selectedTabIsPressed = false;

                    //TODO need to just repaint the tab area!

                    tabPane.repaint();

                }

                //forward the event

                delegate.mouseReleased(e);

                //hack: The super method *should* be setting the mouse-over property correctly

                //here, but it doesn't. That is, when the mouse is released, whatever tab is below the

                //released mouse should be in rollover state. But, if you select a tab and don't

                //move the mouse, this doesn't happen. Hence, forwarding the event.

                delegate2.mouseMoved(e);

            }

        };

    }

    /**

     * @inheritDoc

     */

    @Override

    protected int getTabLabelShiftX(int tabPlacement, int tabIndex, boolean isSelected) {

        if (nudgeSelectedLabel) {

            return super.getTabLabelShiftX(tabPlacement, tabIndex, isSelected);

        } else {

            return 0;

        }

    }

    /**

     * @inheritDoc

     */

    @Override

    protected int getTabLabelShiftY(int tabPlacement, int tabIndex, boolean isSelected) {

        if (nudgeSelectedLabel) {

            return super.getTabLabelShiftY(tabPlacement, tabIndex, isSelected);

        } else {

            return 0;

        }

    }

    /**

     * Notifies this UI delegate to repaint the specified component.

     * This method paints the component background, then calls

     * the {@link #paint(SynthContext,Graphics)} method.

     *

     * <p>In general, this method does not need to be overridden by subclasses.

     * All Look and Feel rendering code should reside in the {@code paint} method.

     *

     * @param g the {@code Graphics} object used for painting

     * @param c the component being painted

     * @see #paint(SynthContext,Graphics)

     */

    @Override

    public void update(Graphics g, JComponent c) {

        SynthContext context = getContext(c);

        SynthLookAndFeel.update(context, g);

        context.getPainter().paintTabbedPaneBackground(context,

                          g, 0, 0, c.getWidth(), c.getHeight());

        paint(context, g);

        context.dispose();

    }

    /**

     * @inheritDoc

     */

    @Override

    protected int getBaseline(int tab) {

        if (tabPane.getTabComponentAt(tab) != null ||

                getTextViewForTab(tab) != null) {

            return super.getBaseline(tab);

        }

        String title = tabPane.getTitleAt(tab);

        Font font = tabContext.getStyle().getFont(tabContext);

        FontMetrics metrics = getFontMetrics(font);

        Icon icon = getIconForTab(tab);

        textRect.setBounds(0, 0, 0, 0);

        iconRect.setBounds(0, 0, 0, 0);

        calcRect.setBounds(0, 0, Short.MAX_VALUE, maxTabHeight);

        tabContext.getStyle().getGraphicsUtils(tabContext).layoutText(

                tabContext, metrics, title, icon, SwingUtilities.CENTER,

                SwingUtilities.CENTER, SwingUtilities.LEADING,

                SwingUtilities.CENTER, calcRect,

                iconRect, textRect, textIconGap);

        return textRect.y + metrics.getAscent() + getBaselineOffset();

    }

    /**

     * @inheritDoc

     */

    @Override

    public void paintBorder(SynthContext context, Graphics g, int x,

                            int y, int w, int h) {

        context.getPainter().paintTabbedPaneBorder(context, g, x, y, w, h);

    }

    /**

     * Paints the specified component according to the Look and Feel.

     * <p>This method is not used by Synth Look and Feel.

     * Painting is handled by the {@link #paint(SynthContext,Graphics)} method.

     *

     * @param g the {@code Graphics} object used for painting

     * @param c the component being painted

     * @see #paint(SynthContext,Graphics)

     */

    @Override

    public void paint(Graphics g, JComponent c) {

        SynthContext context = getContext(c);

        paint(context, g);

        context.dispose();

    }

    /**

     * Paints the specified component.

     *

     * @param context context for the component being painted

     * @param g the {@code Graphics} object used for painting

     * @see #update(Graphics,JComponent)

     */

    protected void paint(SynthContext context, Graphics g) {

        int selectedIndex = tabPane.getSelectedIndex();

        int tabPlacement = tabPane.getTabPlacement();

        ensureCurrentLayout();

        // Paint tab area

        // If scrollable tabs are enabled, the tab area will be

        // painted by the scrollable tab panel instead.

        //

        if (!scrollableTabLayoutEnabled()) { // WRAP_TAB_LAYOUT

            Insets insets = tabPane.getInsets();

            int x = insets.left;

            int y = insets.top;

            int width = tabPane.getWidth() - insets.left - insets.right;

            int height = tabPane.getHeight() - insets.top - insets.bottom;

            int size;

            switch(tabPlacement) {

            case LEFT:

                width = calculateTabAreaWidth(tabPlacement, runCount,

                                              maxTabWidth);

                break;

            case RIGHT:

                size = calculateTabAreaWidth(tabPlacement, runCount,

                                             maxTabWidth);

                x = x + width - size;

                width = size;

                break;

            case BOTTOM:

                size = calculateTabAreaHeight(tabPlacement, runCount,

                                              maxTabHeight);

                y = y + height - size;

                height = size;

                break;

            case TOP:

            default:

                height = calculateTabAreaHeight(tabPlacement, runCount,

                                                maxTabHeight);

            }

            tabAreaBounds.setBounds(x, y, width, height);

            if (g.getClipBounds().intersects(tabAreaBounds)) {

                paintTabArea(tabAreaContext, g, tabPlacement,

                         selectedIndex, tabAreaBounds);

            }

        }

        // Paint content border

        paintContentBorder(tabContentContext, g, tabPlacement, selectedIndex);

    }

    private void paintTabArea(SynthContext ss, Graphics g,

                                int tabPlacement, int selectedIndex,

                                Rectangle tabAreaBounds) {

        Rectangle clipRect = g.getClipBounds();

        //if the tab area's states should match that of the selected tab, then

        //first update the selected tab's states, then set the state

        //for the tab area to match

        //otherwise, restore the tab area's state to ENABLED (which is the

        //only supported state otherwise).

        if (tabAreaStatesMatchSelectedTab && selectedIndex >= 0) {

            updateTabContext(selectedIndex, true, selectedTabIsPressed,

                              (getRolloverTab() == selectedIndex),

                              (getFocusIndex() == selectedIndex));