trunk/libjava/classpath/javax/swing/plaf/basic/BasicArrowButton.java

   1 /* BasicArrowButton.java --
   2    Copyright (C) 2004, 2005, 2006 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package javax.swing.plaf.basic;
  40
  41 import java.awt.Color;
  42 import java.awt.Dimension;
  43 import java.awt.Graphics;
  44 import java.awt.Polygon;
  45
  46 import javax.swing.ButtonModel;
  47 import javax.swing.JButton;
  48 import javax.swing.SwingConstants;
  49
  50 /**
  51  * A button that displays an arrow (triangle) that points {@link #NORTH},
  52  * {@link #SOUTH}, {@link #EAST} or {@link #WEST}.  This button is used by
  53  * the {@link BasicComboBoxUI} class.
  54  *
  55  * @see BasicComboBoxUI#createArrowButton
  56  */
  57 public class BasicArrowButton extends JButton implements SwingConstants
  58 {
  59
  60   /**
  61    * The direction that the arrow points.
  62    *
  63    * @see #getDirection()
  64    */
  65   protected int direction;
  66
  67   /**
  68    * The color the arrow is painted in if disabled and the bottom and right
  69    * edges of the button.
  70    * This is package-private to avoid an accessor method.
  71    */
  72   transient Color shadow = Color.GRAY;
  73
  74   /**
  75    * The color the arrow is painted in if enabled and the bottom and right
  76    * edges of the button.
  77    * This is package-private to avoid an accessor method.
  78    */
  79   transient Color darkShadow = new Color(102, 102, 102);
  80
  81   /**
  82    * The top and left edges of the button.
  83    * This is package-private to avoid an accessor method.
  84    */
  85   transient Color highlight = Color.WHITE;
  86
  87   /**
  88    * Creates a new <code>BasicArrowButton</code> object with an arrow pointing
  89    * in the specified direction.  If the <code>direction</code> is not one of
  90    * the specified constants, no arrow is drawn.
  91    *
  92    * @param direction The direction the arrow points in (one of:
  93    * {@link #NORTH}, {@link #SOUTH}, {@link #EAST} and {@link #WEST}).
  94    */
  95   public BasicArrowButton(int direction)
  96   {
  97     super();
  98     setDirection(direction);
  99     setFocusable(false);
 100   }
 101
 102   /**
 103    * Creates a new BasicArrowButton object with the given colors and
 104    * direction.
 105    *
 106    * @param direction The direction to point in (one of:
 107    * {@link #NORTH}, {@link #SOUTH}, {@link #EAST} and {@link #WEST}).
 108    * @param background The background color.
 109    * @param shadow The shadow color.
 110    * @param darkShadow The dark shadow color.
 111    * @param highlight The highlight color.
 112    */
 113   public BasicArrowButton(int direction, Color background, Color shadow,
 114                           Color darkShadow, Color highlight)
 115   {
 116     this(direction);
 117     setBackground(background);
 118     this.shadow = shadow;
 119     this.darkShadow = darkShadow;
 120     this.highlight = highlight;
 121     setFocusable(false);
 122   }
 123
 124   /**
 125    * Returns whether the focus can traverse to this component.  This method
 126    * always returns <code>false</code>.
 127    *
 128    * @return <code>false</code>.
 129    */
 130   public boolean isFocusTraversable()
 131   {
 132     return false;
 133   }
 134
 135   /**
 136    * Returns the direction of the arrow (one of: {@link #NORTH},
 137    * {@link #SOUTH}, {@link #EAST} and {@link #WEST}).
 138    *
 139    * @return The direction of the arrow.
 140    */
 141   public int getDirection()
 142   {
 143     return direction;
 144   }
 145
 146   /**
 147    * Sets the direction of the arrow.
 148    *
 149    * @param dir The new direction of the arrow (one of: {@link #NORTH},
 150    *            {@link #SOUTH}, {@link #EAST} and {@link #WEST}).
 151    */
 152   public void setDirection(int dir)
 153   {
 154     this.direction = dir;
 155   }
 156
 157   /**
 158    * Paints the arrow button. The painting is delegated to the
 159    * paintTriangle method.
 160    *
 161    * @param g The Graphics object to paint with.
 162    */
 163   public void paint(Graphics g)
 164   {
 165     super.paint(g);
 166
 167     int height = getHeight();
 168     int size = height / 4;
 169
 170     int x = (getWidth() - size) / 2;
 171     int y = (height - size) / 2;
 172
 173     ButtonModel m = getModel();
 174     if (m.isArmed())
 175       {
 176         x++;
 177         y++;
 178       }
 179
 180     paintTriangle(g, x, y, size, direction, isEnabled());
 181   }
 182
 183   /**
 184    * Returns the preferred size of the arrow button.
 185    *
 186    * @return The preferred size (always 16 x 16).
 187    */
 188   public Dimension getPreferredSize()
 189   {
 190     // since Dimension is NOT immutable, we must return a new instance
 191     // every time (if we return a cached value, the caller might modify it)
 192     // - tests show that the reference implementation does the same.
 193     return new Dimension(16, 16);
 194   }
 195
 196   /**
 197    * Returns the minimum size of the arrow button.
 198    *
 199    * @return The minimum size (always 5 x 5).
 200    */
 201   public Dimension getMinimumSize()
 202   {
 203     // since Dimension is NOT immutable, we must return a new instance
 204     // every time (if we return a cached value, the caller might modify it)
 205     // - tests show that the reference implementation does the same.
 206     return new Dimension(5, 5);
 207   }
 208
 209   /**
 210    * Returns the maximum size of the arrow button.
 211    *
 212    * @return The maximum size (always Integer.MAX_VALUE x Integer.MAX_VALUE).
 213    */
 214   public Dimension getMaximumSize()
 215   {
 216     // since Dimension is NOT immutable, we must return a new instance
 217     // every time (if we return a cached value, the caller might modify it)
 218     // - tests show that the reference implementation does the same.
 219     return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
 220   }
 221
 222   /**
 223    * Paints a triangle with the given size, location and direction.  It is
 224    * difficult to explain the rationale behind the positioning of the triangle
 225    * relative to the given (x, y) position - by trial and error we seem to
 226    * match the behaviour of the reference implementation (which is missing a
 227    * specification for this method).
 228    *
 229    * @param g  the graphics device.
 230    * @param x  the x-coordinate for the triangle's location.
 231    * @param y  the y-coordinate for the triangle's location.
 232    * @param size  the arrow size (depth).
 233    * @param direction  the direction of the arrow (one of: {@link #NORTH},
 234    *            {@link #SOUTH}, {@link #EAST} and {@link #WEST}).
 235    * @param isEnabled  if <code>true</code> the arrow is drawn in the enabled
 236    *                   state, otherwise it is drawn in the disabled state.
 237    */
 238   public void paintTriangle(Graphics g, int x, int y, int size, int direction,
 239                             boolean isEnabled)
 240   {
 241     Color savedColor = g.getColor();
 242     switch (direction)
 243       {
 244       case NORTH:
 245         paintTriangleNorth(g, x, y, size, isEnabled);
 246         break;
 247       case SOUTH:
 248         paintTriangleSouth(g, x, y, size, isEnabled);
 249         break;
 250       case LEFT:
 251       case WEST:
 252         paintTriangleWest(g, x, y, size, isEnabled);
 253         break;
 254       case RIGHT:
 255       case EAST:
 256         paintTriangleEast(g, x, y, size, isEnabled);
 257         break;
 258       }
 259     g.setColor(savedColor);
 260   }
 261
 262   /**
 263    * Paints an upward-pointing triangle.  This method is called by the
 264    * {@link #paintTriangle(Graphics, int, int, int, int, boolean)} method.
 265    *
 266    * @param g  the graphics device.
 267    * @param x  the x-coordinate for the anchor point.
 268    * @param y  the y-coordinate for the anchor point.
 269    * @param size  the arrow size (depth).
 270    * @param isEnabled  if <code>true</code> the arrow is drawn in the enabled
 271    *                   state, otherwise it is drawn in the disabled state.
 272    */
 273   private void paintTriangleNorth(Graphics g, int x, int y, int size,
 274           boolean isEnabled)
 275   {
 276     int tipX = x + (size - 2) / 2;
 277     int tipY = y;
 278     int baseX1 = tipX - (size - 1);
 279     int baseX2 = tipX + (size - 1);
 280     int baseY = y + (size - 1);
 281     Polygon triangle = new Polygon();
 282     triangle.addPoint(tipX, tipY);
 283     triangle.addPoint(baseX1, baseY);
 284     triangle.addPoint(baseX2, baseY);
 285     if (isEnabled)
 286      {
 287        g.setColor(Color.DARK_GRAY);
 288        g.fillPolygon(triangle);
 289        g.drawPolygon(triangle);
 290      }
 291     else
 292      {
 293        g.setColor(Color.GRAY);
 294        g.fillPolygon(triangle);
 295        g.drawPolygon(triangle);
 296        g.setColor(Color.WHITE);
 297        g.drawLine(baseX1 + 1, baseY + 1, baseX2 + 1, baseY + 1);
 298      }
 299   }
 300
 301   /**
 302    * Paints an downward-pointing triangle.  This method is called by the
 303    * {@link #paintTriangle(Graphics, int, int, int, int, boolean)} method.
 304    *
 305    * @param g  the graphics device.
 306    * @param x  the x-coordinate for the anchor point.
 307    * @param y  the y-coordinate for the anchor point.
 308    * @param size  the arrow size (depth).
 309    * @param isEnabled  if <code>true</code> the arrow is drawn in the enabled
 310    *                   state, otherwise it is drawn in the disabled state.
 311    */
 312   private void paintTriangleSouth(Graphics g, int x, int y, int size,
 313           boolean isEnabled)
 314   {
 315     int tipX = x + (size - 2) / 2;
 316     int tipY = y + (size - 1);
 317     int baseX1 = tipX - (size - 1);
 318     int baseX2 = tipX + (size - 1);
 319     int baseY = y;
 320     Polygon triangle = new Polygon();
 321     triangle.addPoint(tipX, tipY);
 322     triangle.addPoint(baseX1, baseY);
 323     triangle.addPoint(baseX2, baseY);
 324     if (isEnabled)
 325      {
 326        g.setColor(Color.DARK_GRAY);
 327        g.fillPolygon(triangle);
 328        g.drawPolygon(triangle);
 329      }
 330     else
 331      {
 332        g.setColor(Color.GRAY);
 333        g.fillPolygon(triangle);
 334        g.drawPolygon(triangle);
 335        g.setColor(Color.WHITE);
 336        g.drawLine(tipX + 1, tipY, baseX2, baseY + 1);
 337        g.drawLine(tipX + 1, tipY + 1, baseX2 + 1, baseY + 1);
 338      }
 339   }
 340
 341   /**
 342    * Paints a right-pointing triangle.  This method is called by the
 343    * {@link #paintTriangle(Graphics, int, int, int, int, boolean)} method.
 344    *
 345    * @param g  the graphics device.
 346    * @param x  the x-coordinate for the anchor point.
 347    * @param y  the y-coordinate for the anchor point.
 348    * @param size  the arrow size (depth).
 349    * @param isEnabled  if <code>true</code> the arrow is drawn in the enabled
 350    *                   state, otherwise it is drawn in the disabled state.
 351    */
 352   private void paintTriangleEast(Graphics g, int x, int y, int size,
 353           boolean isEnabled)
 354   {
 355     int tipX = x + (size - 1);
 356     int tipY = y + (size - 2) / 2;
 357     int baseX = x;
 358     int baseY1 = tipY - (size - 1);
 359     int baseY2 = tipY + (size - 1);
 360
 361     Polygon triangle = new Polygon();
 362     triangle.addPoint(tipX, tipY);
 363     triangle.addPoint(baseX, baseY1);
 364     triangle.addPoint(baseX, baseY2);
 365     if (isEnabled)
 366      {
 367        g.setColor(Color.DARK_GRAY);
 368        g.fillPolygon(triangle);
 369        g.drawPolygon(triangle);
 370      }
 371     else
 372      {
 373        g.setColor(Color.GRAY);
 374        g.fillPolygon(triangle);
 375        g.drawPolygon(triangle);
 376        g.setColor(Color.WHITE);
 377        g.drawLine(baseX + 1, baseY2, tipX, tipY + 1);
 378        g.drawLine(baseX + 1, baseY2 + 1, tipX + 1, tipY + 1);
 379      }
 380   }
 381
 382   /**
 383    * Paints a left-pointing triangle.  This method is called by the
 384    * {@link #paintTriangle(Graphics, int, int, int, int, boolean)} method.
 385    *
 386    * @param g  the graphics device.
 387    * @param x  the x-coordinate for the anchor point.
 388    * @param y  the y-coordinate for the anchor point.
 389    * @param size  the arrow size (depth).
 390    * @param isEnabled  if <code>true</code> the arrow is drawn in the enabled
 391    *                   state, otherwise it is drawn in the disabled state.
 392    */
 393   private void paintTriangleWest(Graphics g, int x, int y, int size,
 394           boolean isEnabled)
 395   {
 396     int tipX = x;
 397     int tipY = y + (size - 2) / 2;
 398     int baseX = x + (size - 1);
 399     int baseY1 = tipY - (size - 1);
 400     int baseY2 = tipY + (size - 1);
 401
 402     Polygon triangle = new Polygon();
 403     triangle.addPoint(tipX, tipY);
 404     triangle.addPoint(baseX, baseY1);
 405     triangle.addPoint(baseX, baseY2);
 406     if (isEnabled)
 407      {
 408        g.setColor(Color.DARK_GRAY);
 409        g.fillPolygon(triangle);
 410        g.drawPolygon(triangle);
 411      }
 412     else
 413      {
 414        g.setColor(Color.GRAY);
 415        g.fillPolygon(triangle);
 416        g.drawPolygon(triangle);
 417        g.setColor(Color.WHITE);
 418        g.drawLine(baseX + 1, baseY1 + 1, baseX + 1, baseY2 + 1);
 419      }
 420   }
 421
 422 }