| /* BasicArrowButton.java -- | |
| Copyright (C) 2004, 2005, 2006 Free Software Foundation, Inc. | |
| This file is part of GNU Classpath. | |
| GNU Classpath is free software; you can redistribute it and/or modify | |
| it under the terms of the GNU General Public License as published by | |
| the Free Software Foundation; either version 2, or (at your option) | |
| any later version. | |
| GNU Classpath 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 for more details. | |
| You should have received a copy of the GNU General Public License | |
| along with GNU Classpath; see the file COPYING. If not, write to the | |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA | |
| 02110-1301 USA. | |
| Linking this library statically or dynamically with other modules is | |
| making a combined work based on this library. Thus, the terms and | |
| conditions of the GNU General Public License cover the whole | |
| combination. | |
| As a special exception, the copyright holders of this library give you | |
| permission to link this library with independent modules to produce an | |
| executable, regardless of the license terms of these independent | |
| modules, and to copy and distribute the resulting executable under | |
| terms of your choice, provided that you also meet, for each linked | |
| independent module, the terms and conditions of the license of that | |
| module. An independent module is a module which is not derived from | |
| or based on this library. If you modify this library, you may extend | |
| this exception to your version of the library, but you are not | |
| obligated to do so. If you do not wish to do so, delete this | |
| exception statement from your version. */ | |
| package javax.swing.plaf.basic; | |
| import java.awt.Color; | |
| import java.awt.Dimension; | |
| import java.awt.Graphics; | |
| import java.awt.Polygon; | |
| import javax.swing.ButtonModel; | |
| import javax.swing.JButton; | |
| import javax.swing.SwingConstants; | |
| /** | |
| * A button that displays an arrow (triangle) that points {@link #NORTH}, | |
| * {@link #SOUTH}, {@link #EAST} or {@link #WEST}. This button is used by | |
| * the {@link BasicComboBoxUI} class. | |
| * | |
| * @see BasicComboBoxUI#createArrowButton | |
| */ | |
| public class BasicArrowButton extends JButton implements SwingConstants | |
| { | |
| /** | |
| * The direction that the arrow points. | |
| * | |
| * @see #getDirection() | |
| */ | |
| protected int direction; | |
| /** | |
| * The color the arrow is painted in if disabled and the bottom and right | |
| * edges of the button. | |
| * This is package-private to avoid an accessor method. | |
| */ | |
| transient Color shadow = Color.GRAY; | |
| /** | |
| * The color the arrow is painted in if enabled and the bottom and right | |
| * edges of the button. | |
| * This is package-private to avoid an accessor method. | |
| */ | |
| transient Color darkShadow = new Color(102, 102, 102); | |
| /** | |
| * The top and left edges of the button. | |
| * This is package-private to avoid an accessor method. | |
| */ | |
| transient Color highlight = Color.WHITE; | |
| /** | |
| * Creates a new <code>BasicArrowButton</code> object with an arrow pointing | |
| * in the specified direction. If the <code>direction</code> is not one of | |
| * the specified constants, no arrow is drawn. | |
| * | |
| * @param direction The direction the arrow points in (one of: | |
| * {@link #NORTH}, {@link #SOUTH}, {@link #EAST} and {@link #WEST}). | |
| */ | |
| public BasicArrowButton(int direction) | |
| { | |
| super(); | |
| setDirection(direction); | |
| setFocusable(false); | |
| } | |
| /** | |
| * Creates a new BasicArrowButton object with the given colors and | |
| * direction. | |
| * | |
| * @param direction The direction to point in (one of: | |
| * {@link #NORTH}, {@link #SOUTH}, {@link #EAST} and {@link #WEST}). | |
| * @param background The background color. | |
| * @param shadow The shadow color. | |
| * @param darkShadow The dark shadow color. | |
| * @param highlight The highlight color. | |
| */ | |
| public BasicArrowButton(int direction, Color background, Color shadow, | |
| Color darkShadow, Color highlight) | |
| { | |
| this(direction); | |
| setBackground(background); | |
| this.shadow = shadow; | |
| this.darkShadow = darkShadow; | |
| this.highlight = highlight; | |
| setFocusable(false); | |
| } | |
| /** | |
| * Returns whether the focus can traverse to this component. This method | |
| * always returns <code>false</code>. | |
| * | |
| * @return <code>false</code>. | |
| */ | |
| public boolean isFocusTraversable() | |
| { | |
| return false; | |
| } | |
| /** | |
| * Returns the direction of the arrow (one of: {@link #NORTH}, | |
| * {@link #SOUTH}, {@link #EAST} and {@link #WEST}). | |
| * | |
| * @return The direction of the arrow. | |
| */ | |
| public int getDirection() | |
| { | |
| return direction; | |
| } | |
| /** | |
| * Sets the direction of the arrow. | |
| * | |
| * @param dir The new direction of the arrow (one of: {@link #NORTH}, | |
| * {@link #SOUTH}, {@link #EAST} and {@link #WEST}). | |
| */ | |
| public void setDirection(int dir) | |
| { | |
| this.direction = dir; | |
| } | |
| /** | |
| * Paints the arrow button. The painting is delegated to the | |
| * paintTriangle method. | |
| * | |
| * @param g The Graphics object to paint with. | |
| */ | |
| public void paint(Graphics g) | |
| { | |
| super.paint(g); | |
| int height = getHeight(); | |
| int size = height / 4; | |
| int x = (getWidth() - size) / 2; | |
| int y = (height - size) / 2; | |
| ButtonModel m = getModel(); | |
| if (m.isArmed()) | |
| { | |
| x++; | |
| y++; | |
| } | |
| paintTriangle(g, x, y, size, direction, isEnabled()); | |
| } | |
| /** | |
| * Returns the preferred size of the arrow button. | |
| * | |
| * @return The preferred size (always 16 x 16). | |
| */ | |
| public Dimension getPreferredSize() | |
| { | |
| // since Dimension is NOT immutable, we must return a new instance | |
| // every time (if we return a cached value, the caller might modify it) | |
| // - tests show that the reference implementation does the same. | |
| return new Dimension(16, 16); | |
| } | |
| /** | |
| * Returns the minimum size of the arrow button. | |
| * | |
| * @return The minimum size (always 5 x 5). | |
| */ | |
| public Dimension getMinimumSize() | |
| { | |
| // since Dimension is NOT immutable, we must return a new instance | |
| // every time (if we return a cached value, the caller might modify it) | |
| // - tests show that the reference implementation does the same. | |
| return new Dimension(5, 5); | |
| } | |
| /** | |
| * Returns the maximum size of the arrow button. | |
| * | |
| * @return The maximum size (always Integer.MAX_VALUE x Integer.MAX_VALUE). | |
| */ | |
| public Dimension getMaximumSize() | |
| { | |
| // since Dimension is NOT immutable, we must return a new instance | |
| // every time (if we return a cached value, the caller might modify it) | |
| // - tests show that the reference implementation does the same. | |
| return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE); | |
| } | |
| /** | |
| * Paints a triangle with the given size, location and direction. It is | |
| * difficult to explain the rationale behind the positioning of the triangle | |
| * relative to the given (x, y) position - by trial and error we seem to | |
| * match the behaviour of the reference implementation (which is missing a | |
| * specification for this method). | |
| * | |
| * @param g the graphics device. | |
| * @param x the x-coordinate for the triangle's location. | |
| * @param y the y-coordinate for the triangle's location. | |
| * @param size the arrow size (depth). | |
| * @param direction the direction of the arrow (one of: {@link #NORTH}, | |
| * {@link #SOUTH}, {@link #EAST} and {@link #WEST}). | |
| * @param isEnabled if <code>true</code> the arrow is drawn in the enabled | |
| * state, otherwise it is drawn in the disabled state. | |
| */ | |
| public void paintTriangle(Graphics g, int x, int y, int size, int direction, | |
| boolean isEnabled) | |
| { | |
| Color savedColor = g.getColor(); | |
| switch (direction) | |
| { | |
| case NORTH: | |
| paintTriangleNorth(g, x, y, size, isEnabled); | |
| break; | |
| case SOUTH: | |
| paintTriangleSouth(g, x, y, size, isEnabled); | |
| break; | |
| case LEFT: | |
| case WEST: | |
| paintTriangleWest(g, x, y, size, isEnabled); | |
| break; | |
| case RIGHT: | |
| case EAST: | |
| paintTriangleEast(g, x, y, size, isEnabled); | |
| break; | |
| } | |
| g.setColor(savedColor); | |
| } | |
| /** | |
| * Paints an upward-pointing triangle. This method is called by the | |
| * {@link #paintTriangle(Graphics, int, int, int, int, boolean)} method. | |
| * | |
| * @param g the graphics device. | |
| * @param x the x-coordinate for the anchor point. | |
| * @param y the y-coordinate for the anchor point. | |
| * @param size the arrow size (depth). | |
| * @param isEnabled if <code>true</code> the arrow is drawn in the enabled | |
| * state, otherwise it is drawn in the disabled state. | |
| */ | |
| private void paintTriangleNorth(Graphics g, int x, int y, int size, | |
| boolean isEnabled) | |
| { | |
| int tipX = x + (size - 2) / 2; | |
| int tipY = y; | |
| int baseX1 = tipX - (size - 1); | |
| int baseX2 = tipX + (size - 1); | |
| int baseY = y + (size - 1); | |
| Polygon triangle = new Polygon(); | |
| triangle.addPoint(tipX, tipY); | |
| triangle.addPoint(baseX1, baseY); | |
| triangle.addPoint(baseX2, baseY); | |
| if (isEnabled) | |
| { | |
| g.setColor(Color.DARK_GRAY); | |
| g.fillPolygon(triangle); | |
| g.drawPolygon(triangle); | |
| } | |
| else | |
| { | |
| g.setColor(Color.GRAY); | |
| g.fillPolygon(triangle); | |
| g.drawPolygon(triangle); | |
| g.setColor(Color.WHITE); | |
| g.drawLine(baseX1 + 1, baseY + 1, baseX2 + 1, baseY + 1); | |
| } | |
| } | |
| /** | |
| * Paints an downward-pointing triangle. This method is called by the | |
| * {@link #paintTriangle(Graphics, int, int, int, int, boolean)} method. | |
| * | |
| * @param g the graphics device. | |
| * @param x the x-coordinate for the anchor point. | |
| * @param y the y-coordinate for the anchor point. | |
| * @param size the arrow size (depth). | |
| * @param isEnabled if <code>true</code> the arrow is drawn in the enabled | |
| * state, otherwise it is drawn in the disabled state. | |
| */ | |
| private void paintTriangleSouth(Graphics g, int x, int y, int size, | |
| boolean isEnabled) | |
| { | |
| int tipX = x + (size - 2) / 2; | |
| int tipY = y + (size - 1); | |
| int baseX1 = tipX - (size - 1); | |
| int baseX2 = tipX + (size - 1); | |
| int baseY = y; | |
| Polygon triangle = new Polygon(); | |
| triangle.addPoint(tipX, tipY); | |
| triangle.addPoint(baseX1, baseY); | |
| triangle.addPoint(baseX2, baseY); | |
| if (isEnabled) | |
| { | |
| g.setColor(Color.DARK_GRAY); | |
| g.fillPolygon(triangle); | |
| g.drawPolygon(triangle); | |
| } | |
| else | |
| { | |
| g.setColor(Color.GRAY); | |
| g.fillPolygon(triangle); | |
| g.drawPolygon(triangle); | |
| g.setColor(Color.WHITE); | |
| g.drawLine(tipX + 1, tipY, baseX2, baseY + 1); | |
| g.drawLine(tipX + 1, tipY + 1, baseX2 + 1, baseY + 1); | |
| } | |
| } | |
| /** | |
| * Paints a right-pointing triangle. This method is called by the | |
| * {@link #paintTriangle(Graphics, int, int, int, int, boolean)} method. | |
| * | |
| * @param g the graphics device. | |
| * @param x the x-coordinate for the anchor point. | |
| * @param y the y-coordinate for the anchor point. | |
| * @param size the arrow size (depth). | |
| * @param isEnabled if <code>true</code> the arrow is drawn in the enabled | |
| * state, otherwise it is drawn in the disabled state. | |
| */ | |
| private void paintTriangleEast(Graphics g, int x, int y, int size, | |
| boolean isEnabled) | |
| { | |
| int tipX = x + (size - 1); | |
| int tipY = y + (size - 2) / 2; | |
| int baseX = x; | |
| int baseY1 = tipY - (size - 1); | |
| int baseY2 = tipY + (size - 1); | |
| Polygon triangle = new Polygon(); | |
| triangle.addPoint(tipX, tipY); | |
| triangle.addPoint(baseX, baseY1); | |
| triangle.addPoint(baseX, baseY2); | |
| if (isEnabled) | |
| { | |
| g.setColor(Color.DARK_GRAY); | |
| g.fillPolygon(triangle); | |
| g.drawPolygon(triangle); | |
| } | |
| else | |
| { | |
| g.setColor(Color.GRAY); | |
| g.fillPolygon(triangle); | |
| g.drawPolygon(triangle); | |
| g.setColor(Color.WHITE); | |
| g.drawLine(baseX + 1, baseY2, tipX, tipY + 1); | |
| g.drawLine(baseX + 1, baseY2 + 1, tipX + 1, tipY + 1); | |
| } | |
| } | |
| /** | |
| * Paints a left-pointing triangle. This method is called by the | |
| * {@link #paintTriangle(Graphics, int, int, int, int, boolean)} method. | |
| * | |
| * @param g the graphics device. | |
| * @param x the x-coordinate for the anchor point. | |
| * @param y the y-coordinate for the anchor point. | |
| * @param size the arrow size (depth). | |
| * @param isEnabled if <code>true</code> the arrow is drawn in the enabled | |
| * state, otherwise it is drawn in the disabled state. | |
| */ | |
| private void paintTriangleWest(Graphics g, int x, int y, int size, | |
| boolean isEnabled) | |
| { | |
| int tipX = x; | |
| int tipY = y + (size - 2) / 2; | |
| int baseX = x + (size - 1); | |
| int baseY1 = tipY - (size - 1); | |
| int baseY2 = tipY + (size - 1); | |
| Polygon triangle = new Polygon(); | |
| triangle.addPoint(tipX, tipY); | |
| triangle.addPoint(baseX, baseY1); | |
| triangle.addPoint(baseX, baseY2); | |
| if (isEnabled) | |
| { | |
| g.setColor(Color.DARK_GRAY); | |
| g.fillPolygon(triangle); | |
| g.drawPolygon(triangle); | |
| } | |
| else | |
| { | |
| g.setColor(Color.GRAY); | |
| g.fillPolygon(triangle); | |
| g.drawPolygon(triangle); | |
| g.setColor(Color.WHITE); | |
| g.drawLine(baseX + 1, baseY1 + 1, baseX + 1, baseY2 + 1); | |
| } | |
| } | |
| } |