Back to index...

	/*
	* Copyright (c) 1998, 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 javax.swing.plaf.metal;

	import sun.swing.SwingUtilities2;
	import java.awt.*;
	import java.awt.event.*;
	import javax.swing.*;
	import javax.swing.border.*;
	import javax.swing.event.InternalFrameEvent;
	import java.util.EventListener;
	import java.beans.PropertyChangeListener;
	import java.beans.PropertyChangeEvent;
	import javax.swing.plaf.basic.BasicInternalFrameTitlePane;


	/**
	* Class that manages a JLF title bar
	* @author Steve Wilson
	* @author Brian Beck
	* @since 1.3
	*/

	public class MetalInternalFrameTitlePane extends BasicInternalFrameTitlePane {

	protected boolean isPalette = false;
	protected Icon paletteCloseIcon;
	protected int paletteTitleHeight;

	private static final Border handyEmptyBorder = new EmptyBorder(0,0,0,0);

	/**
	* Key used to lookup Color from UIManager. If this is null,
	* <code>getWindowTitleBackground</code> is used.
	*/
	private String selectedBackgroundKey;
	/**
	* Key used to lookup Color from UIManager. If this is null,
	* <code>getWindowTitleForeground</code> is used.
	*/
	private String selectedForegroundKey;
	/**
	* Key used to lookup shadow color from UIManager. If this is null,
	* <code>getPrimaryControlDarkShadow</code> is used.
	*/
	private String selectedShadowKey;
	/**
	* Boolean indicating the state of the <code>JInternalFrame</code>s
	* closable property at <code>updateUI</code> time.
	*/
	private boolean wasClosable;

	int buttonsWidth = 0;

	MetalBumps activeBumps
	= new MetalBumps( 0, 0,
	MetalLookAndFeel.getPrimaryControlHighlight(),
	MetalLookAndFeel.getPrimaryControlDarkShadow(),
	(UIManager.get("InternalFrame.activeTitleGradient") != null) ? null :
	MetalLookAndFeel.getPrimaryControl() );
	MetalBumps inactiveBumps
	= new MetalBumps( 0, 0,
	MetalLookAndFeel.getControlHighlight(),
	MetalLookAndFeel.getControlDarkShadow(),
	(UIManager.get("InternalFrame.inactiveTitleGradient") != null) ? null :
	MetalLookAndFeel.getControl() );
	MetalBumps paletteBumps;

	private Color activeBumpsHighlight = MetalLookAndFeel.
	getPrimaryControlHighlight();
	private Color activeBumpsShadow = MetalLookAndFeel.
	getPrimaryControlDarkShadow();

	public MetalInternalFrameTitlePane(JInternalFrame f) {
	super( f );
	}

	public void addNotify() {
	super.addNotify();
	// This is done here instead of in installDefaults as I was worried
	// that the BasicInternalFrameUI might not be fully initialized, and
	// that if this resets the closable state the BasicInternalFrameUI
	// Listeners that get notified might be in an odd/uninitialized state.
	updateOptionPaneState();
	}

	protected void installDefaults() {
	super.installDefaults();
	setFont( UIManager.getFont("InternalFrame.titleFont") );
	paletteTitleHeight
	= UIManager.getInt("InternalFrame.paletteTitleHeight");
	paletteCloseIcon = UIManager.getIcon("InternalFrame.paletteCloseIcon");
	wasClosable = frame.isClosable();
	selectedForegroundKey = selectedBackgroundKey = null;
	if (MetalLookAndFeel.usingOcean()) {
	setOpaque(true);
	}
	}

	protected void uninstallDefaults() {
	super.uninstallDefaults();
	if (wasClosable != frame.isClosable()) {
	frame.setClosable(wasClosable);
	}
	}

	protected void createButtons() {
	super.createButtons();

	Boolean paintActive = frame.isSelected() ? Boolean.TRUE:Boolean.FALSE;
	iconButton.putClientProperty("paintActive", paintActive);
	iconButton.setBorder(handyEmptyBorder);

	maxButton.putClientProperty("paintActive", paintActive);
	maxButton.setBorder(handyEmptyBorder);

	closeButton.putClientProperty("paintActive", paintActive);
	closeButton.setBorder(handyEmptyBorder);

	// The palette close icon isn't opaque while the regular close icon is.
	// This makes sure palette close buttons have the right background.
	closeButton.setBackground(MetalLookAndFeel.getPrimaryControlShadow());

	if (MetalLookAndFeel.usingOcean()) {
	iconButton.setContentAreaFilled(false);
	maxButton.setContentAreaFilled(false);
	closeButton.setContentAreaFilled(false);
	}
	}

	/**
	* Override the parent's method to do nothing. Metal frames do not
	* have system menus.
	*/
	protected void assembleSystemMenu() {}

	/**
	* Override the parent's method to do nothing. Metal frames do not
	* have system menus.
	*/
	protected void addSystemMenuItems(JMenu systemMenu) {}

	/**
	* Override the parent's method to do nothing. Metal frames do not
	* have system menus.
	*/
	protected void showSystemMenu() {}

	/**
	* Override the parent's method avoid creating a menu bar. Metal frames
	* do not have system menus.
	*/
	protected void addSubComponents() {
	add(iconButton);
	add(maxButton);
	add(closeButton);
	}

	protected PropertyChangeListener createPropertyChangeListener() {
	return new MetalPropertyChangeHandler();
	}

	protected LayoutManager createLayout() {
	return new MetalTitlePaneLayout();
	}

	class MetalPropertyChangeHandler
	extends BasicInternalFrameTitlePane.PropertyChangeHandler
	{
	public void propertyChange(PropertyChangeEvent evt) {
	String prop = evt.getPropertyName();
	if( prop.equals(JInternalFrame.IS_SELECTED_PROPERTY) ) {
	Boolean b = (Boolean)evt.getNewValue();
	iconButton.putClientProperty("paintActive", b);
	closeButton.putClientProperty("paintActive", b);
	maxButton.putClientProperty("paintActive", b);
	}
	else if ("JInternalFrame.messageType".equals(prop)) {
	updateOptionPaneState();
	frame.repaint();
	}
	super.propertyChange(evt);
	}
	}

	class MetalTitlePaneLayout extends TitlePaneLayout {
	public void addLayoutComponent(String name, Component c) {}
	public void removeLayoutComponent(Component c) {}
	public Dimension preferredLayoutSize(Container c) {
	return minimumLayoutSize(c);
	}

	public Dimension minimumLayoutSize(Container c) {
	// Compute width.
	int width = 30;
	if (frame.isClosable()) {
	width += 21;
	}
	if (frame.isMaximizable()) {
	width += 16 + (frame.isClosable() ? 10 : 4);
	}
	if (frame.isIconifiable()) {
	width += 16 + (frame.isMaximizable() ? 2 :
	(frame.isClosable() ? 10 : 4));
	}
	FontMetrics fm = frame.getFontMetrics(getFont());
	String frameTitle = frame.getTitle();
	int title_w = frameTitle != null ? SwingUtilities2.stringWidth(
	frame, fm, frameTitle) : 0;
	int title_length = frameTitle != null ? frameTitle.length() : 0;

	if (title_length > 2) {
	int subtitle_w = SwingUtilities2.stringWidth(frame, fm,
	frame.getTitle().substring(0, 2) + "...");
	width += (title_w < subtitle_w) ? title_w : subtitle_w;
	}
	else {
	width += title_w;
	}

	// Compute height.
	int height;
	if (isPalette) {
	height = paletteTitleHeight;
	} else {
	int fontHeight = fm.getHeight();
	fontHeight += 7;
	Icon icon = frame.getFrameIcon();
	int iconHeight = 0;
	if (icon != null) {
	// SystemMenuBar forces the icon to be 16x16 or less.
	iconHeight = Math.min(icon.getIconHeight(), 16);
	}
	iconHeight += 5;
	height = Math.max(fontHeight, iconHeight);
	}

	return new Dimension(width, height);
	}

	public void layoutContainer(Container c) {
	boolean leftToRight = MetalUtils.isLeftToRight(frame);

	int w = getWidth();
	int x = leftToRight ? w : 0;
	int y = 2;
	int spacing;

	// assumes all buttons have the same dimensions
	// these dimensions include the borders
	int buttonHeight = closeButton.getIcon().getIconHeight();
	int buttonWidth = closeButton.getIcon().getIconWidth();

	if(frame.isClosable()) {
	if (isPalette) {
	spacing = 3;
	x += leftToRight ? -spacing -(buttonWidth+2) : spacing;
	closeButton.setBounds(x, y, buttonWidth+2, getHeight()-4);
	if( !leftToRight ) x += (buttonWidth+2);
	} else {
	spacing = 4;
	x += leftToRight ? -spacing -buttonWidth : spacing;
	closeButton.setBounds(x, y, buttonWidth, buttonHeight);
	if( !leftToRight ) x += buttonWidth;
	}
	}

	if(frame.isMaximizable() && !isPalette ) {
	spacing = frame.isClosable() ? 10 : 4;
	x += leftToRight ? -spacing -buttonWidth : spacing;
	maxButton.setBounds(x, y, buttonWidth, buttonHeight);
	if( !leftToRight ) x += buttonWidth;
	}

	if(frame.isIconifiable() && !isPalette ) {
	spacing = frame.isMaximizable() ? 2
	: (frame.isClosable() ? 10 : 4);
	x += leftToRight ? -spacing -buttonWidth : spacing;
	iconButton.setBounds(x, y, buttonWidth, buttonHeight);
	if( !leftToRight ) x += buttonWidth;
	}

	buttonsWidth = leftToRight ? w - x : x;
	}
	}

	public void paintPalette(Graphics g) {
	boolean leftToRight = MetalUtils.isLeftToRight(frame);

	int width = getWidth();
	int height = getHeight();

	if (paletteBumps == null) {
	paletteBumps
	= new MetalBumps(0, 0,
	MetalLookAndFeel.getPrimaryControlHighlight(),
	MetalLookAndFeel.getPrimaryControlInfo(),
	MetalLookAndFeel.getPrimaryControlShadow() );
	}

	Color background = MetalLookAndFeel.getPrimaryControlShadow();
	Color darkShadow = MetalLookAndFeel.getPrimaryControlDarkShadow();

	g.setColor(background);
	g.fillRect(0, 0, width, height);

	g.setColor( darkShadow );
	g.drawLine ( 0, height - 1, width, height -1);

	int xOffset = leftToRight ? 4 : buttonsWidth + 4;
	int bumpLength = width - buttonsWidth -2*4;
	int bumpHeight = getHeight() - 4;
	paletteBumps.setBumpArea( bumpLength, bumpHeight );
	paletteBumps.paintIcon( this, g, xOffset, 2);
	}

	public void paintComponent(Graphics g) {
	if(isPalette) {
	paintPalette(g);
	return;
	}

	boolean leftToRight = MetalUtils.isLeftToRight(frame);
	boolean isSelected = frame.isSelected();

	int width = getWidth();
	int height = getHeight();

	Color background = null;
	Color foreground = null;
	Color shadow = null;

	MetalBumps bumps;
	String gradientKey;

	if (isSelected) {
	if (!MetalLookAndFeel.usingOcean()) {
	closeButton.setContentAreaFilled(true);
	maxButton.setContentAreaFilled(true);
	iconButton.setContentAreaFilled(true);
	}
	if (selectedBackgroundKey != null) {
	background = UIManager.getColor(selectedBackgroundKey);
	}
	if (background == null) {
	background = MetalLookAndFeel.getWindowTitleBackground();
	}
	if (selectedForegroundKey != null) {
	foreground = UIManager.getColor(selectedForegroundKey);
	}
	if (selectedShadowKey != null) {
	shadow = UIManager.getColor(selectedShadowKey);
	}
	if (shadow == null) {
	shadow = MetalLookAndFeel.getPrimaryControlDarkShadow();
	}
	if (foreground == null) {
	foreground = MetalLookAndFeel.getWindowTitleForeground();
	}
	activeBumps.setBumpColors(activeBumpsHighlight, activeBumpsShadow,
	UIManager.get("InternalFrame.activeTitleGradient") !=
	null ? null : background);
	bumps = activeBumps;
	gradientKey = "InternalFrame.activeTitleGradient";
	} else {
	if (!MetalLookAndFeel.usingOcean()) {
	closeButton.setContentAreaFilled(false);
	maxButton.setContentAreaFilled(false);
	iconButton.setContentAreaFilled(false);
	}
	background = MetalLookAndFeel.getWindowTitleInactiveBackground();
	foreground = MetalLookAndFeel.getWindowTitleInactiveForeground();
	shadow = MetalLookAndFeel.getControlDarkShadow();
	bumps = inactiveBumps;
	gradientKey = "InternalFrame.inactiveTitleGradient";
	}

	if (!MetalUtils.drawGradient(this, g, gradientKey, 0, 0, width,
	height, true)) {
	g.setColor(background);
	g.fillRect(0, 0, width, height);
	}

	g.setColor( shadow );
	g.drawLine ( 0, height - 1, width, height -1);
	g.drawLine ( 0, 0, 0 ,0);
	g.drawLine ( width - 1, 0 , width -1, 0);


	int titleLength;
	int xOffset = leftToRight ? 5 : width - 5;
	String frameTitle = frame.getTitle();

	Icon icon = frame.getFrameIcon();
	if ( icon != null ) {
	if( !leftToRight )
	xOffset -= icon.getIconWidth();
	int iconY = ((height / 2) - (icon.getIconHeight() /2));
	icon.paintIcon(frame, g, xOffset, iconY);
	xOffset += leftToRight ? icon.getIconWidth() + 5 : -5;
	}

	if(frameTitle != null) {
	Font f = getFont();
	g.setFont(f);
	FontMetrics fm = SwingUtilities2.getFontMetrics(frame, g, f);
	int fHeight = fm.getHeight();

	g.setColor(foreground);

	int yOffset = ( (height - fm.getHeight() ) / 2 ) + fm.getAscent();

	Rectangle rect = new Rectangle(0, 0, 0, 0);
	if (frame.isIconifiable()) { rect = iconButton.getBounds(); }
	else if (frame.isMaximizable()) { rect = maxButton.getBounds(); }
	else if (frame.isClosable()) { rect = closeButton.getBounds(); }
	int titleW;

	if( leftToRight ) {
	if (rect.x == 0) {
	rect.x = frame.getWidth()-frame.getInsets().right-2;
	}
	titleW = rect.x - xOffset - 4;
	frameTitle = getTitle(frameTitle, fm, titleW);
	} else {
	titleW = xOffset - rect.x - rect.width - 4;
	frameTitle = getTitle(frameTitle, fm, titleW);
	xOffset -= SwingUtilities2.stringWidth(frame, fm, frameTitle);
	}

	titleLength = SwingUtilities2.stringWidth(frame, fm, frameTitle);
	SwingUtilities2.drawString(frame, g, frameTitle, xOffset, yOffset);
	xOffset += leftToRight ? titleLength + 5 : -5;
	}

	int bumpXOffset;
	int bumpLength;
	if( leftToRight ) {
	bumpLength = width - buttonsWidth - xOffset - 5;
	bumpXOffset = xOffset;
	} else {
	bumpLength = xOffset - buttonsWidth - 5;
	bumpXOffset = buttonsWidth + 5;
	}
	int bumpYOffset = 3;
	int bumpHeight = getHeight() - (2 * bumpYOffset);
	bumps.setBumpArea( bumpLength, bumpHeight );
	bumps.paintIcon(this, g, bumpXOffset, bumpYOffset);
	}

	public void setPalette(boolean b) {
	isPalette = b;

	if (isPalette) {
	closeButton.setIcon(paletteCloseIcon);
	if( frame.isMaximizable() )
	remove(maxButton);
	if( frame.isIconifiable() )
	remove(iconButton);
	} else {
	closeButton.setIcon(closeIcon);
	if( frame.isMaximizable() )
	add(maxButton);
	if( frame.isIconifiable() )
	add(iconButton);
	}
	revalidate();
	repaint();
	}

	/**
	* Updates any state dependant upon the JInternalFrame being shown in
	* a <code>JOptionPane</code>.
	*/
	private void updateOptionPaneState() {
	int type = -2;
	boolean closable = wasClosable;
	Object obj = frame.getClientProperty("JInternalFrame.messageType");

	if (obj == null) {
	// Don't change the closable state unless in an JOptionPane.
	return;
	}
	if (obj instanceof Integer) {
	type = ((Integer) obj).intValue();
	}
	switch (type) {
	case JOptionPane.ERROR_MESSAGE:
	selectedBackgroundKey =
	"OptionPane.errorDialog.titlePane.background";
	selectedForegroundKey =
	"OptionPane.errorDialog.titlePane.foreground";
	selectedShadowKey = "OptionPane.errorDialog.titlePane.shadow";
	closable = false;
	break;
	case JOptionPane.QUESTION_MESSAGE:
	selectedBackgroundKey =
	"OptionPane.questionDialog.titlePane.background";
	selectedForegroundKey =
	"OptionPane.questionDialog.titlePane.foreground";
	selectedShadowKey =
	"OptionPane.questionDialog.titlePane.shadow";
	closable = false;
	break;
	case JOptionPane.WARNING_MESSAGE:
	selectedBackgroundKey =
	"OptionPane.warningDialog.titlePane.background";
	selectedForegroundKey =
	"OptionPane.warningDialog.titlePane.foreground";
	selectedShadowKey = "OptionPane.warningDialog.titlePane.shadow";
	closable = false;
	break;
	case JOptionPane.INFORMATION_MESSAGE:
	case JOptionPane.PLAIN_MESSAGE:
	selectedBackgroundKey = selectedForegroundKey = selectedShadowKey =
	null;
	closable = false;
	break;
	default:
	selectedBackgroundKey = selectedForegroundKey = selectedShadowKey =
	null;
	break;
	}
	if (closable != frame.isClosable()) {
	frame.setClosable(closable);
	}
	}
	}

Back to index...