1 /*

     2  * Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

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

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package com.sun.java.swing.plaf.windows;

    27 

    28 import java.awt.*;

    29 

    30 import javax.swing.plaf.basic.*;

    31 import javax.swing.plaf.*;

    32 import javax.swing.*;

    33 import java.util.Set;

    34 import java.util.HashSet;

    35 import java.awt.event.*;

    36 

    37 import static com.sun.java.swing.plaf.windows.TMSchema.*;

    38 import static com.sun.java.swing.plaf.windows.XPStyle.Skin;

    39 

    40 

    41 /**

    42  * Windows rendition of the component.

    43  * <p>

    44  * <strong>Warning:</strong>

    45  * Serialized objects of this class will not be compatible with

    46  * future Swing releases.  The current serialization support is appropriate

    47  * for short term storage or RMI between applications running the same

    48  * version of Swing.  A future release of Swing will provide support for

    49  * long term persistence.

    50  */

    51 public class WindowsTabbedPaneUI extends BasicTabbedPaneUI {

    52     /**

    53      * Keys to use for forward focus traversal when the JComponent is

    54      * managing focus.

    55      */

    56     private static Set<KeyStroke> managingFocusForwardTraversalKeys;

    57 

    58     /**

    59      * Keys to use for backward focus traversal when the JComponent is

    60      * managing focus.

    61      */

    62     private static Set<KeyStroke> managingFocusBackwardTraversalKeys;

    63 

    64     private boolean contentOpaque = true;

    65 

    66     @SuppressWarnings("deprecation")

    67     protected void installDefaults() {

    68         super.installDefaults();

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

    70 

    71         // focus forward traversal key

    72         if (managingFocusForwardTraversalKeys==null) {

    73             managingFocusForwardTraversalKeys = new HashSet<KeyStroke>();

    74             managingFocusForwardTraversalKeys.add(KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0));

    75         }

    76         tabPane.setFocusTraversalKeys(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, managingFocusForwardTraversalKeys);

    77         // focus backward traversal key

    78         if (managingFocusBackwardTraversalKeys==null) {

    79             managingFocusBackwardTraversalKeys = new HashSet<KeyStroke>();

    80             managingFocusBackwardTraversalKeys.add( KeyStroke.getKeyStroke(KeyEvent.VK_TAB, InputEvent.SHIFT_MASK));

    81         }

    82         tabPane.setFocusTraversalKeys(KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, managingFocusBackwardTraversalKeys);

    83     }

    84 

    85     protected void uninstallDefaults() {

    86         // sets the focus forward and backward traversal keys to null

    87         // to restore the defaults

    88         tabPane.setFocusTraversalKeys(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, null);

    89         tabPane.setFocusTraversalKeys(KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, null);

    90         super.uninstallDefaults();

    91     }

    92 

    93     public static ComponentUI createUI(JComponent c) {

    94         return new WindowsTabbedPaneUI();

    95     }

    96 

    97     protected void setRolloverTab(int index) {

    98         // Rollover is only supported on XP

    99         if (XPStyle.getXP() != null) {

   100             int oldRolloverTab = getRolloverTab();

   101             super.setRolloverTab(index);

   102             Rectangle r1 = null;

   103             Rectangle r2 = null;

   104             if ( (oldRolloverTab >= 0) && (oldRolloverTab < tabPane.getTabCount()) ) {

   105                 r1 = getTabBounds(tabPane, oldRolloverTab);

   106             }

   107             if (index >= 0) {

   108                 r2 = getTabBounds(tabPane, index);

   109             }

   110             if (r1 != null) {

   111                 if (r2 != null) {

   112                     tabPane.repaint(r1.union(r2));

   113                 } else {

   114                     tabPane.repaint(r1);

   115                 }

   116             } else if (r2 != null) {

   117                 tabPane.repaint(r2);

   118             }

   119         }

   120     }

   121 

   122     protected void paintContentBorder(Graphics g, int tabPlacement, int selectedIndex) {

   123         XPStyle xp = XPStyle.getXP();

   124         if (xp != null && (contentOpaque || tabPane.isOpaque())) {

   125             Skin skin = xp.getSkin(tabPane, Part.TABP_PANE);

   126             if (skin != null) {

   127                 Insets insets = tabPane.getInsets();

   128                 // Note: don't call getTabAreaInsets(), because it causes rotation.

   129                 // Make sure "TabbedPane.tabsOverlapBorder" is set to true in WindowsLookAndFeel

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

   131                 int x = insets.left;

   132                 int y = insets.top;

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

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

   135 

   136                 // Expand area by tabAreaInsets.bottom to allow tabs to overlap onto the border.

   137                 if (tabPlacement == LEFT || tabPlacement == RIGHT) {

   138                     int tabWidth = calculateTabAreaWidth(tabPlacement, runCount, maxTabWidth);

   139                     if (tabPlacement == LEFT) {

   140                         x += (tabWidth - tabAreaInsets.bottom);

   141                     }

   142                     w -= (tabWidth - tabAreaInsets.bottom);

   143                 } else {

   144                     int tabHeight = calculateTabAreaHeight(tabPlacement, runCount, maxTabHeight);

   145                     if (tabPlacement == TOP) {

   146                         y += (tabHeight - tabAreaInsets.bottom);

   147                     }

   148                     h -= (tabHeight - tabAreaInsets.bottom);

   149                 }

   150 

   151                 paintRotatedSkin(g, skin, tabPlacement, x, y, w, h, null);

   152                 return;

   153             }

   154         }

   155         super.paintContentBorder(g, tabPlacement, selectedIndex);

   156     }

   157 

   158     protected void paintTabBackground(Graphics g, int tabPlacement, int tabIndex,

   159                                       int x, int y, int w, int h, boolean isSelected ) {

   160         if (XPStyle.getXP() == null) {

   161             super.paintTabBackground(g, tabPlacement, tabIndex, x, y, w, h, isSelected);

   162         }

   163     }

   164 

   165     protected void paintTabBorder(Graphics g, int tabPlacement, int tabIndex,

   166                                   int x, int y, int w, int h, boolean isSelected ) {

   167         XPStyle xp = XPStyle.getXP();

   168         if (xp != null) {

   169             Part part;

   170 

   171             int tabCount = tabPane.getTabCount();

   172             int tabRun = getRunForTab(tabCount, tabIndex);

   173             if (tabRuns[tabRun] == tabIndex) {

   174                 part = Part.TABP_TABITEMLEFTEDGE;

   175             } else if (tabCount > 1 && lastTabInRun(tabCount, tabRun) == tabIndex) {

   176                 part = Part.TABP_TABITEMRIGHTEDGE;

   177                 if (isSelected) {

   178                     // Align with right edge

   179                     if (tabPlacement == TOP || tabPlacement == BOTTOM) {

   180                         w++;

   181                     } else {

   182                         h++;

   183                     }

   184                 }

   185             } else {

   186                 part = Part.TABP_TABITEM;

   187             }

   188 

   189             State state = State.NORMAL;

   190             if (isSelected) {

   191                 state = State.SELECTED;

   192             } else if (tabIndex == getRolloverTab()) {

   193                 state = State.HOT;

   194             }

   195 

   196             paintRotatedSkin(g, xp.getSkin(tabPane, part), tabPlacement, x, y, w, h, state);

   197         } else {

   198             super.paintTabBorder(g, tabPlacement, tabIndex, x, y, w, h, isSelected);

   199         }

   200     }

   201 

   202     private void paintRotatedSkin(Graphics g, Skin skin, int tabPlacement,

   203                                   int x, int y, int w, int h, State state) {

   204         Graphics2D g2d = (Graphics2D)g.create();

   205         g2d.translate(x, y);

   206         switch (tabPlacement) {

   207            case RIGHT:  g2d.translate(w, 0);

   208                         g2d.rotate(Math.toRadians(90.0));

   209                         skin.paintSkin(g2d, 0, 0, h, w, state);

   210                         break;

   211 

   212            case LEFT:   g2d.scale(-1.0, 1.0);

   213                         g2d.rotate(Math.toRadians(90.0));

   214                         skin.paintSkin(g2d, 0, 0, h, w, state);

   215                         break;

   216 

   217            case BOTTOM: g2d.translate(0, h);

   218                         g2d.scale(-1.0, 1.0);

   219                         g2d.rotate(Math.toRadians(180.0));

   220                         skin.paintSkin(g2d, 0, 0, w, h, state);

   221                         break;

   222 

   223            case TOP:

   224            default:     skin.paintSkin(g2d, 0, 0, w, h, state);

   225         }

   226         g2d.dispose();

   227     }

   228 }