Back to index...

	/*
	* Copyright (c) 1997, 2008, 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 com.sun.java.swing.plaf.windows;

	import java.awt.*;

	import javax.swing.plaf.basic.*;
	import javax.swing.plaf.*;
	import javax.swing.*;
	import java.util.Set;
	import java.util.HashSet;
	import java.awt.event.*;

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


	/**
	* Windows rendition of the component.
	* <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. A future release of Swing will provide support for
	* long term persistence.
	*/
	public class WindowsTabbedPaneUI extends BasicTabbedPaneUI {
	/**
	* Keys to use for forward focus traversal when the JComponent is
	* managing focus.
	*/
	private static Set<KeyStroke> managingFocusForwardTraversalKeys;

	/**
	* Keys to use for backward focus traversal when the JComponent is
	* managing focus.
	*/
	private static Set<KeyStroke> managingFocusBackwardTraversalKeys;

	private boolean contentOpaque = true;

	protected void installDefaults() {
	super.installDefaults();
	contentOpaque = UIManager.getBoolean("TabbedPane.contentOpaque");

	// focus forward traversal key
	if (managingFocusForwardTraversalKeys==null) {
	managingFocusForwardTraversalKeys = new HashSet<KeyStroke>();
	managingFocusForwardTraversalKeys.add(KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0));
	}
	tabPane.setFocusTraversalKeys(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, managingFocusForwardTraversalKeys);
	// focus backward traversal key
	if (managingFocusBackwardTraversalKeys==null) {
	managingFocusBackwardTraversalKeys = new HashSet<KeyStroke>();
	managingFocusBackwardTraversalKeys.add( KeyStroke.getKeyStroke(KeyEvent.VK_TAB, InputEvent.SHIFT_MASK));
	}
	tabPane.setFocusTraversalKeys(KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, managingFocusBackwardTraversalKeys);
	}

	protected void uninstallDefaults() {
	// sets the focus forward and backward traversal keys to null
	// to restore the defaults
	tabPane.setFocusTraversalKeys(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, null);
	tabPane.setFocusTraversalKeys(KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, null);
	super.uninstallDefaults();
	}

	public static ComponentUI createUI(JComponent c) {
	return new WindowsTabbedPaneUI();
	}

	protected void setRolloverTab(int index) {
	// Rollover is only supported on XP
	if (XPStyle.getXP() != null) {
	int oldRolloverTab = getRolloverTab();
	super.setRolloverTab(index);
	Rectangle r1 = null;
	Rectangle r2 = null;
	if ( (oldRolloverTab >= 0) && (oldRolloverTab < tabPane.getTabCount()) ) {
	r1 = getTabBounds(tabPane, oldRolloverTab);
	}
	if (index >= 0) {
	r2 = getTabBounds(tabPane, index);
	}
	if (r1 != null) {
	if (r2 != null) {
	tabPane.repaint(r1.union(r2));
	} else {
	tabPane.repaint(r1);
	}
	} else if (r2 != null) {
	tabPane.repaint(r2);
	}
	}
	}

	protected void paintContentBorder(Graphics g, int tabPlacement, int selectedIndex) {
	XPStyle xp = XPStyle.getXP();
	if (xp != null && (contentOpaque \|\| tabPane.isOpaque())) {
	Skin skin = xp.getSkin(tabPane, Part.TABP_PANE);
	if (skin != null) {
	Insets insets = tabPane.getInsets();
	// Note: don't call getTabAreaInsets(), because it causes rotation.
	// Make sure "TabbedPane.tabsOverlapBorder" is set to true in WindowsLookAndFeel
	Insets tabAreaInsets = UIManager.getInsets("TabbedPane.tabAreaInsets");
	int x = insets.left;
	int y = insets.top;
	int w = tabPane.getWidth() - insets.right - insets.left;
	int h = tabPane.getHeight() - insets.top - insets.bottom;

	// Expand area by tabAreaInsets.bottom to allow tabs to overlap onto the border.
	if (tabPlacement == LEFT \|\| tabPlacement == RIGHT) {
	int tabWidth = calculateTabAreaWidth(tabPlacement, runCount, maxTabWidth);
	if (tabPlacement == LEFT) {
	x += (tabWidth - tabAreaInsets.bottom);
	}
	w -= (tabWidth - tabAreaInsets.bottom);
	} else {
	int tabHeight = calculateTabAreaHeight(tabPlacement, runCount, maxTabHeight);
	if (tabPlacement == TOP) {
	y += (tabHeight - tabAreaInsets.bottom);
	}
	h -= (tabHeight - tabAreaInsets.bottom);
	}

	paintRotatedSkin(g, skin, tabPlacement, x, y, w, h, null);
	return;
	}
	}
	super.paintContentBorder(g, tabPlacement, selectedIndex);
	}

	protected void paintTabBackground(Graphics g, int tabPlacement, int tabIndex,
	int x, int y, int w, int h, boolean isSelected ) {
	if (XPStyle.getXP() == null) {
	super.paintTabBackground(g, tabPlacement, tabIndex, x, y, w, h, isSelected);
	}
	}

	protected void paintTabBorder(Graphics g, int tabPlacement, int tabIndex,
	int x, int y, int w, int h, boolean isSelected ) {
	XPStyle xp = XPStyle.getXP();
	if (xp != null) {
	Part part;

	int tabCount = tabPane.getTabCount();
	int tabRun = getRunForTab(tabCount, tabIndex);
	if (tabRuns[tabRun] == tabIndex) {
	part = Part.TABP_TABITEMLEFTEDGE;
	} else if (tabCount > 1 && lastTabInRun(tabCount, tabRun) == tabIndex) {
	part = Part.TABP_TABITEMRIGHTEDGE;
	if (isSelected) {
	// Align with right edge
	if (tabPlacement == TOP \|\| tabPlacement == BOTTOM) {
	w++;
	} else {
	h++;
	}
	}
	} else {
	part = Part.TABP_TABITEM;
	}

	State state = State.NORMAL;
	if (isSelected) {
	state = State.SELECTED;
	} else if (tabIndex == getRolloverTab()) {
	state = State.HOT;
	}

	paintRotatedSkin(g, xp.getSkin(tabPane, part), tabPlacement, x, y, w, h, state);
	} else {
	super.paintTabBorder(g, tabPlacement, tabIndex, x, y, w, h, isSelected);
	}
	}

	private void paintRotatedSkin(Graphics g, Skin skin, int tabPlacement,
	int x, int y, int w, int h, State state) {
	Graphics2D g2d = (Graphics2D)g.create();
	g2d.translate(x, y);
	switch (tabPlacement) {
	case RIGHT: g2d.translate(w, 0);
	g2d.rotate(Math.toRadians(90.0));
	skin.paintSkin(g2d, 0, 0, h, w, state);
	break;

	case LEFT: g2d.scale(-1.0, 1.0);
	g2d.rotate(Math.toRadians(90.0));
	skin.paintSkin(g2d, 0, 0, h, w, state);
	break;

	case BOTTOM: g2d.translate(0, h);
	g2d.scale(-1.0, 1.0);
	g2d.rotate(Math.toRadians(180.0));
	skin.paintSkin(g2d, 0, 0, w, h, state);
	break;

	case TOP:
	default: skin.paintSkin(g2d, 0, 0, w, h, state);
	}
	g2d.dispose();
	}
	}

Back to index...