Back to index...

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

	import sun.swing.SwingUtilities2;
	import javax.swing.*;
	import javax.swing.border.*;
	import javax.swing.plaf.*;

	import java.awt.Color;
	import java.awt.Component;
	import java.awt.Dimension;
	import java.awt.Font;
	import java.awt.FontMetrics;
	import java.awt.Graphics;
	import java.awt.Insets;
	import java.awt.Point;
	import java.awt.Rectangle;

	/**
	* Factory object that can vend Icons appropriate for the basic L & F.
	* <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.
	*
	* @author Amy Fowler
	*/
	public class MotifBorders {

	public static class BevelBorder extends AbstractBorder implements UIResource {
	private Color darkShadow = UIManager.getColor("controlShadow");
	private Color lightShadow = UIManager.getColor("controlLtHighlight");
	private boolean isRaised;

	public BevelBorder(boolean isRaised, Color darkShadow, Color lightShadow) {
	this.isRaised = isRaised;
	this.darkShadow = darkShadow;
	this.lightShadow = lightShadow;
	}

	public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
	g.setColor((isRaised) ? lightShadow : darkShadow);
	g.drawLine(x, y, x+w-1, y); // top
	g.drawLine(x, y+h-1, x, y+1); // left

	g.setColor((isRaised) ? darkShadow : lightShadow);
	g.drawLine(x+1, y+h-1, x+w-1, y+h-1); // bottom
	g.drawLine(x+w-1, y+h-1, x+w-1, y+1); // right
	}

	public Insets getBorderInsets(Component c, Insets insets) {
	insets.set(1, 1, 1, 1);
	return insets;
	}

	public boolean isOpaque(Component c) {
	return true;
	}

	}


	public static class FocusBorder extends AbstractBorder implements UIResource {
	private Color focus;
	private Color control;

	public FocusBorder(Color control, Color focus) {
	this.control = control;
	this.focus = focus;
	}

	public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
	if (c.hasFocus()) {
	g.setColor(focus);
	g.drawRect(x, y, w-1, h-1);
	} else {
	g.setColor(control);
	g.drawRect(x, y, w-1, h-1);
	}
	}

	public Insets getBorderInsets(Component c, Insets insets) {
	insets.set(1, 1, 1, 1);
	return insets;
	}
	}


	public static class ButtonBorder extends AbstractBorder implements UIResource {
	protected Color focus = UIManager.getColor("activeCaptionBorder");
	protected Color shadow = UIManager.getColor("Button.shadow");
	protected Color highlight = UIManager.getColor("Button.light");
	protected Color darkShadow;

	public ButtonBorder(Color shadow, Color highlight, Color darkShadow, Color focus) {
	this.shadow = shadow;
	this.highlight = highlight;
	this.darkShadow = darkShadow;
	this.focus = focus;
	}

	public void paintBorder(Component c, Graphics g, int x, int y, int w, int h) {
	boolean isPressed = false;
	boolean hasFocus = false;
	boolean canBeDefault = false;
	boolean isDefault = false;

	if (c instanceof AbstractButton) {
	AbstractButton b = (AbstractButton)c;
	ButtonModel model = b.getModel();

	isPressed = (model.isArmed() && model.isPressed());
	hasFocus = (model.isArmed() && isPressed) \|\|
	(b.isFocusPainted() && b.hasFocus());
	if (b instanceof JButton) {
	canBeDefault = ((JButton)b).isDefaultCapable();
	isDefault = ((JButton)b).isDefaultButton();
	}
	}
	int bx1 = x+1;
	int by1 = y+1;
	int bx2 = x+w-2;
	int by2 = y+h-2;

	if (canBeDefault) {
	if (isDefault) {
	g.setColor(shadow);
	g.drawLine(x+3, y+3, x+3, y+h-4);
	g.drawLine(x+3, y+3, x+w-4, y+3);

	g.setColor(highlight);
	g.drawLine(x+4, y+h-4, x+w-4, y+h-4);
	g.drawLine(x+w-4, y+3, x+w-4, y+h-4);
	}
	bx1 +=6;
	by1 += 6;
	bx2 -= 6;
	by2 -= 6;
	}

	if (hasFocus) {
	g.setColor(focus);
	if (isDefault) {
	g.drawRect(x, y, w-1, h-1);
	} else {
	g.drawRect(bx1-1, by1-1, bx2-bx1+2, by2-by1+2);
	}
	}

	g.setColor(isPressed? shadow : highlight);
	g.drawLine(bx1, by1, bx2, by1);
	g.drawLine(bx1, by1, bx1, by2);

	g.setColor(isPressed? highlight : shadow);
	g.drawLine(bx2, by1+1, bx2, by2);
	g.drawLine(bx1+1, by2, bx2, by2);
	}

	public Insets getBorderInsets(Component c, Insets insets) {
	int thickness = (c instanceof JButton && ((JButton)c).isDefaultCapable())? 8 : 2;
	insets.set(thickness, thickness, thickness, thickness);
	return insets;
	}

	}

	public static class ToggleButtonBorder extends ButtonBorder {

	public ToggleButtonBorder(Color shadow, Color highlight, Color darkShadow, Color focus) {
	super(shadow, highlight, darkShadow, focus);
	}

	public void paintBorder(Component c, Graphics g, int x, int y,
	int width, int height) {
	if (c instanceof AbstractButton) {
	AbstractButton b = (AbstractButton)c;
	ButtonModel model = b.getModel();

	if (model.isArmed() && model.isPressed() \|\| model.isSelected()) {
	drawBezel(g, x, y, width, height,
	(model.isPressed() \|\| model.isSelected()),
	b.isFocusPainted() && b.hasFocus(), shadow, highlight, darkShadow, focus);
	} else {
	drawBezel(g, x, y, width, height,
	false, b.isFocusPainted() && b.hasFocus(),
	shadow, highlight, darkShadow, focus);
	}
	} else {
	drawBezel(g, x, y, width, height, false, false,
	shadow, highlight, darkShadow, focus);
	}
	}

	public Insets getBorderInsets(Component c, Insets insets) {
	insets.set(2, 2, 3, 3);
	return insets;
	}
	}

	public static class MenuBarBorder extends ButtonBorder {

	public MenuBarBorder(Color shadow, Color highlight, Color darkShadow, Color focus) {
	super(shadow, highlight, darkShadow, focus);
	}

	public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
	if (!(c instanceof JMenuBar)) {
	return;
	}
	JMenuBar menuBar = (JMenuBar)c;
	if (menuBar.isBorderPainted() == true) {
	// this draws the MenuBar border
	Dimension size = menuBar.getSize();
	drawBezel(g,x,y,size.width,size.height,false,false,
	shadow, highlight, darkShadow, focus);
	}
	}

	public Insets getBorderInsets(Component c, Insets insets) {
	insets.set(6, 6, 6, 6);
	return insets;
	}
	}

	public static class FrameBorder extends AbstractBorder implements UIResource {

	JComponent jcomp;
	Color frameHighlight;
	Color frameColor;
	Color frameShadow;

	// The width of the border
	public final static int BORDER_SIZE = 5;

	/** Constructs an FrameBorder for the JComponent <b>comp</b>.
	*/
	public FrameBorder(JComponent comp) {
	jcomp = comp;
	}

	/** Sets the FrameBorder's JComponent.
	*/
	public void setComponent(JComponent comp) {
	jcomp = comp;
	}

	/** Returns the FrameBorder's JComponent.
	* @see #setComponent
	*/
	public JComponent component() {
	return jcomp;
	}

	protected Color getFrameHighlight() {
	return frameHighlight;
	}

	protected Color getFrameColor() {
	return frameColor;
	}

	protected Color getFrameShadow() {
	return frameShadow;
	}

	public Insets getBorderInsets(Component c, Insets newInsets) {
	newInsets.set(BORDER_SIZE, BORDER_SIZE, BORDER_SIZE, BORDER_SIZE);
	return newInsets;
	}

	/** Draws the FrameBorder's top border.
	*/
	protected boolean drawTopBorder(Component c, Graphics g,
	int x, int y, int width, int height) {
	Rectangle titleBarRect = new Rectangle(x, y, width, BORDER_SIZE);
	if (!g.getClipBounds().intersects(titleBarRect)) {
	return false;
	}

	int maxX = width - 1;
	int maxY = BORDER_SIZE - 1;

	// Draw frame
	g.setColor(frameColor);
	g.drawLine(x, y + 2, maxX - 2, y + 2);
	g.drawLine(x, y + 3, maxX - 2, y + 3);
	g.drawLine(x, y + 4, maxX - 2, y + 4);

	// Draw highlights
	g.setColor(frameHighlight);
	g.drawLine(x, y, maxX, y);
	g.drawLine(x, y + 1, maxX, y + 1);
	g.drawLine(x, y + 2, x, y + 4);
	g.drawLine(x + 1, y + 2, x + 1, y + 4);

	// Draw shadows
	g.setColor(frameShadow);
	g.drawLine(x + 4, y + 4, maxX - 4, y + 4);
	g.drawLine(maxX, y + 1, maxX, maxY);
	g.drawLine(maxX - 1, y + 2, maxX - 1, maxY);

	return true;
	}

	/** Draws the FrameBorder's left border.
	*/
	protected boolean drawLeftBorder(Component c, Graphics g, int x, int y,
	int width, int height) {
	Rectangle borderRect =
	new Rectangle(0, 0, getBorderInsets(c).left, height);
	if (!g.getClipBounds().intersects(borderRect)) {
	return false;
	}

	int startY = BORDER_SIZE;

	g.setColor(frameHighlight);
	g.drawLine(x, startY, x, height - 1);
	g.drawLine(x + 1, startY, x + 1, height - 2);

	g.setColor(frameColor);
	g.fillRect(x + 2, startY, x + 2, height - 3);

	g.setColor(frameShadow);
	g.drawLine(x + 4, startY, x + 4, height - 5);

	return true;
	}

	/** Draws the FrameBorder's right border.
	*/
	protected boolean drawRightBorder(Component c, Graphics g, int x, int y,
	int width, int height) {
	Rectangle borderRect = new Rectangle(
	width - getBorderInsets(c).right, 0,
	getBorderInsets(c).right, height);
	if (!g.getClipBounds().intersects(borderRect)) {
	return false;
	}

	int startX = width - getBorderInsets(c).right;
	int startY = BORDER_SIZE;

	g.setColor(frameColor);
	g.fillRect(startX + 1, startY, 2, height - 1);

	g.setColor(frameShadow);
	g.fillRect(startX + 3, startY, 2, height - 1);

	g.setColor(frameHighlight);
	g.drawLine(startX, startY, startX, height - 1);

	return true;
	}

	/** Draws the FrameBorder's bottom border.
	*/
	protected boolean drawBottomBorder(Component c, Graphics g, int x, int y,
	int width, int height) {
	Rectangle borderRect;
	int marginHeight, startY;

	borderRect = new Rectangle(0, height - getBorderInsets(c).bottom,
	width, getBorderInsets(c).bottom);
	if (!g.getClipBounds().intersects(borderRect)) {
	return false;
	}

	startY = height - getBorderInsets(c).bottom;

	g.setColor(frameShadow);
	g.drawLine(x + 1, height - 1, width - 1, height - 1);
	g.drawLine(x + 2, height - 2, width - 2, height - 2);

	g.setColor(frameColor);
	g.fillRect(x + 2, startY + 1, width - 4, 2);

	g.setColor(frameHighlight);
	g.drawLine(x + 5, startY, width - 5, startY);

	return true;
	}

	// Returns true if the associated component has focus.
	protected boolean isActiveFrame() {
	return jcomp.hasFocus();
	}

	/** Draws the FrameBorder in the given Rect. Calls
	* <b>drawTitleBar</b>, <b>drawLeftBorder</b>, <b>drawRightBorder</b> and
	* <b>drawBottomBorder</b>.
	*/
	public void paintBorder(Component c, Graphics g,
	int x, int y, int width, int height) {
	if (isActiveFrame()) {
	frameColor = UIManager.getColor("activeCaptionBorder");
	} else {
	frameColor = UIManager.getColor("inactiveCaptionBorder");
	}
	frameHighlight = frameColor.brighter();
	frameShadow = frameColor.darker().darker();

	drawTopBorder(c, g, x, y, width, height);
	drawLeftBorder(c, g, x, y, width, height);
	drawRightBorder(c, g, x, y, width, height);
	drawBottomBorder(c, g, x, y, width, height);
	}
	}

	public static class InternalFrameBorder extends FrameBorder {

	JInternalFrame frame;

	// The size of the bounding box for Motif frame corners.
	public final static int CORNER_SIZE = 24;

	/** Constructs an InternalFrameBorder for the InternalFrame
	* <b>aFrame</b>.
	*/
	public InternalFrameBorder(JInternalFrame aFrame) {
	super(aFrame);
	frame = aFrame;
	}

	/** Sets the InternalFrameBorder's InternalFrame.
	*/
	public void setFrame(JInternalFrame aFrame) {
	frame = aFrame;
	}

	/** Returns the InternalFrameBorder's InternalFrame.
	* @see #setFrame
	*/
	public JInternalFrame frame() {
	return frame;
	}

	/** Returns the width of the InternalFrameBorder's resize controls,
	* appearing along the InternalFrameBorder's bottom border. Clicking
	* and dragging within these controls lets the user change both the
	* InternalFrame's width and height, while dragging between the controls
	* constrains resizing to just the vertical dimension. Override this
	* method if you implement your own bottom border painting and use a
	* resize control with a different size.
	*/
	public int resizePartWidth() {
	if (!frame.isResizable()) {
	return 0;
	}
	return FrameBorder.BORDER_SIZE;
	}

	/** Draws the InternalFrameBorder's top border.
	*/
	protected boolean drawTopBorder(Component c, Graphics g,
	int x, int y, int width, int height) {
	if (super.drawTopBorder(c, g, x, y, width, height) &&
	frame.isResizable()) {
	g.setColor(getFrameShadow());
	g.drawLine(CORNER_SIZE - 1, y + 1, CORNER_SIZE - 1, y + 4);
	g.drawLine(width - CORNER_SIZE - 1, y + 1,
	width - CORNER_SIZE - 1, y + 4);

	g.setColor(getFrameHighlight());
	g.drawLine(CORNER_SIZE, y, CORNER_SIZE, y + 4);
	g.drawLine(width - CORNER_SIZE, y, width - CORNER_SIZE, y + 4);
	return true;
	}
	return false;
	}

	/** Draws the InternalFrameBorder's left border.
	*/
	protected boolean drawLeftBorder(Component c, Graphics g, int x, int y,
	int width, int height) {
	if (super.drawLeftBorder(c, g, x, y, width, height) &&
	frame.isResizable()) {
	g.setColor(getFrameHighlight());
	int topY = y + CORNER_SIZE;
	g.drawLine(x, topY, x + 4, topY);
	int bottomY = height - CORNER_SIZE;
	g.drawLine(x + 1, bottomY, x + 5, bottomY);
	g.setColor(getFrameShadow());
	g.drawLine(x + 1, topY - 1, x + 5, topY - 1);
	g.drawLine(x + 1, bottomY - 1, x + 5, bottomY - 1);
	return true;
	}
	return false;
	}

	/** Draws the InternalFrameBorder's right border.
	*/
	protected boolean drawRightBorder(Component c, Graphics g, int x, int y,
	int width, int height) {
	if (super.drawRightBorder(c, g, x, y, width, height) &&
	frame.isResizable()) {
	int startX = width - getBorderInsets(c).right;
	g.setColor(getFrameHighlight());
	int topY = y + CORNER_SIZE;
	g.drawLine(startX, topY, width - 2, topY);
	int bottomY = height - CORNER_SIZE;
	g.drawLine(startX + 1, bottomY, startX + 3, bottomY);
	g.setColor(getFrameShadow());
	g.drawLine(startX + 1, topY - 1, width - 2, topY - 1);
	g.drawLine(startX + 1, bottomY - 1, startX + 3, bottomY - 1);
	return true;
	}
	return false;
	}

	/** Draws the InternalFrameBorder's bottom border.
	*/
	protected boolean drawBottomBorder(Component c, Graphics g, int x, int y,
	int width, int height) {
	if (super.drawBottomBorder(c, g, x, y, width, height) &&
	frame.isResizable()) {
	int startY = height - getBorderInsets(c).bottom;

	g.setColor(getFrameShadow());
	g.drawLine(CORNER_SIZE - 1, startY + 1,
	CORNER_SIZE - 1, height - 1);
	g.drawLine(width - CORNER_SIZE, startY + 1,
	width - CORNER_SIZE, height - 1);

	g.setColor(getFrameHighlight());
	g.drawLine(CORNER_SIZE, startY, CORNER_SIZE, height - 2);
	g.drawLine(width - CORNER_SIZE + 1, startY,
	width - CORNER_SIZE + 1, height - 2);
	return true;
	}
	return false;
	}

	// Returns true if the associated internal frame has focus.
	protected boolean isActiveFrame() {
	return frame.isSelected();
	}
	}

	public static void drawBezel(Graphics g, int x, int y, int w, int h,
	boolean isPressed, boolean hasFocus,
	Color shadow, Color highlight,
	Color darkShadow, Color focus) {

	Color oldColor = g.getColor();
	g.translate(x, y);

	if (isPressed) {
	if (hasFocus){
	g.setColor(focus);
	g.drawRect(0, 0, w-1, h-1);
	}
	g.setColor(shadow); // inner border
	g.drawRect(1, 1, w-3, h-3);

	g.setColor(highlight); // inner 3D border
	g.drawLine(2, h-3, w-3, h-3);
	g.drawLine(w-3, 2, w-3, h-4);

	} else {
	if (hasFocus) {
	g.setColor(focus);
	g.drawRect(0, 0, w-1, h-1);

	g.setColor(highlight); // inner 3D border
	g.drawLine(1, 1, 1, h-3);
	g.drawLine(2, 1, w-4, 1);

	g.setColor(shadow);
	g.drawLine(2, h-3, w-3, h-3);
	g.drawLine(w-3, 1, w-3, h-4);

	g.setColor(darkShadow); // black drop shadow __\|
	g.drawLine(1, h-2, w-2, h-2);
	g.drawLine(w-2, h-2, w-2, 1);
	} else {
	g.setColor(highlight); // inner 3D border
	g.drawLine(1,1,1,h-3);
	g.drawLine(2,1,w-4,1);
	g.setColor(shadow);
	g.drawLine(2,h-3,w-3,h-3);
	g.drawLine(w-3,1,w-3,h-4);

	g.setColor(darkShadow); // black drop shadow __\|
	g.drawLine(1,h-2,w-2,h-2);
	g.drawLine(w-2,h-2,w-2,0);

	}
	g.translate(-x, -y);
	}
	g.setColor(oldColor);
	}

	public static class MotifPopupMenuBorder extends AbstractBorder implements UIResource {
	protected Font font;
	protected Color background;
	protected Color foreground;
	protected Color shadowColor;
	protected Color highlightColor;

	// Space between the border and text
	static protected final int TEXT_SPACING = 2;

	// Space for the separator under the title
	static protected final int GROOVE_HEIGHT = 2;

	/**
	* Creates a MotifPopupMenuBorder instance
	*
	*/
	public MotifPopupMenuBorder(
	Font titleFont,
	Color bgColor,
	Color fgColor,
	Color shadow,
	Color highlight) {
	this.font = titleFont;
	this.background = bgColor;
	this.foreground = fgColor;
	this.shadowColor = shadow;
	this.highlightColor = highlight;
	}

	/**
	* Paints the border for the specified component with the
	* specified position and size.
	* @param c the component for which this border is being painted
	* @param g the paint graphics
	* @param x the x position of the painted border
	* @param y the y position of the painted border
	* @param width the width of the painted border
	* @param height the height of the painted border
	*/
	public void paintBorder(Component c, Graphics g, int x, int y, int width, int height) {
	if (!(c instanceof JPopupMenu)) {
	return;
	}

	Font origFont = g.getFont();
	Color origColor = g.getColor();
	JPopupMenu popup = (JPopupMenu)c;

	String title = popup.getLabel();
	if (title == null) {
	return;
	}

	g.setFont(font);

	FontMetrics fm = SwingUtilities2.getFontMetrics(popup, g, font);
	int fontHeight = fm.getHeight();
	int descent = fm.getDescent();
	int ascent = fm.getAscent();
	Point textLoc = new Point();
	int stringWidth = SwingUtilities2.stringWidth(popup, fm,
	title);

	textLoc.y = y + ascent + TEXT_SPACING;
	textLoc.x = x + ((width - stringWidth) / 2);

	g.setColor(background);
	g.fillRect(textLoc.x - TEXT_SPACING, textLoc.y - (fontHeight-descent),
	stringWidth + (2 * TEXT_SPACING), fontHeight - descent);
	g.setColor(foreground);
	SwingUtilities2.drawString(popup, g, title, textLoc.x, textLoc.y);

	MotifGraphicsUtils.drawGroove(g, x, textLoc.y + TEXT_SPACING,
	width, GROOVE_HEIGHT,
	shadowColor, highlightColor);

	g.setFont(origFont);
	g.setColor(origColor);
	}

	/**
	* Reinitialize the insets parameter with this Border's current Insets.
	* @param c the component for which this border insets value applies
	* @param insets the object to be reinitialized
	*/
	public Insets getBorderInsets(Component c, Insets insets) {
	if (!(c instanceof JPopupMenu)) {
	return insets;
	}
	FontMetrics fm;
	int descent = 0;
	int ascent = 16;

	String title = ((JPopupMenu)c).getLabel();
	if (title == null) {
	insets.left = insets.top = insets.right = insets.bottom = 0;
	return insets;
	}

	fm = c.getFontMetrics(font);

	if(fm != null) {
	descent = fm.getDescent();
	ascent = fm.getAscent();
	}

	insets.top += ascent + descent + TEXT_SPACING + GROOVE_HEIGHT;
	return insets;
	}

	}

	}

Back to index...