libjava/classpath/javax/swing/JLabel.java

   1 /* JLabel.java --
   2    Copyright (C) 2002, 2004, 2005  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;
  40
  41 import java.awt.Component;
  42 import java.awt.Font;
  43 import java.awt.Image;
  44 import java.awt.Point;
  45 import java.awt.Rectangle;
  46 import java.awt.event.KeyEvent;
  47
  48 import javax.accessibility.Accessible;
  49 import javax.accessibility.AccessibleContext;
  50 import javax.accessibility.AccessibleExtendedComponent;
  51 import javax.accessibility.AccessibleText;
  52 import javax.swing.plaf.LabelUI;
  53 import javax.swing.text.AttributeSet;
  54 import javax.swing.text.SimpleAttributeSet;
  55
  56 /**
  57  * A swing widget that displays a text message and/or an icon.
  58  */
  59 public class JLabel extends JComponent implements Accessible, SwingConstants
  60 {
  61
  62   /**
  63    * Accessibility support for JLabel.
  64    */
  65   protected class AccessibleJLabel
  66     extends JComponent.AccessibleJComponent
  67     implements AccessibleText, AccessibleExtendedComponent
  68   {
  69     /**
  70      * Returns the selected text. This is an empty string since JLabels
  71      * are not selectable.
  72      *
  73      * @return the selected text
  74      */
  75     public String getSelectedText()
  76     {
  77       // We return "" here since JLabel's text is not selectable.
  78       return "";
  79     }
  80
  81     /**
  82      * Returns the start index of the selected text.
  83      *
  84      * @return the start index of the selected text
  85      */
  86     public int getSelectionStart()
  87     {
  88       // TODO: Figure out what should be returned here, because JLabels don't
  89       // allow selection. I guess -1 for now.
  90       return -1;
  91     }
  92
  93     /**
  94      * Returns the end index of the selected text.
  95      *
  96      * @return the end index of the selected text
  97      */
  98     public int getSelectionEnd()
  99     {
 100       // TODO: Figure out what should be returned here, because JLabels don't
 101       // allow selection. I guess -1 for now.
 102       return -1;
 103     }
 104
 105     /**
 106      * Returns an {@link AttributeSet} that reflects the text attributes of
 107      * the specified character. We return an empty
 108      * <code>AttributeSet</code> here, because JLabels don't support text
 109      * attributes (at least not yet).
 110      *
 111      * @param index the index of the character
 112      *
 113      * @return an {@link AttributeSet} that reflects the text attributes of
 114      *         the specified character
 115      */
 116     public AttributeSet getCharacterAttribute(int index)
 117     {
 118       return new SimpleAttributeSet();
 119     }
 120
 121     /**
 122      * Returns the character, word or sentence at the specified index. The
 123      * <code>part</code> parameter determines what is returned, the character,
 124      * word or sentence after the index.
 125      *
 126      * @param part one of {@link AccessibleText#CHARACTER},
 127      *             {@link AccessibleText#WORD} or
 128      *             {@link AccessibleText#SENTENCE}, specifying what is returned
 129      * @param index the index
 130      *
 131      * @return the character, word or sentence after <code>index</code>
 132      */
 133     public String getAtIndex(int part, int index)
 134     {
 135       String result = "";
 136       int startIndex = -1;
 137       int endIndex = -1;
 138       switch(part)
 139         {
 140         case AccessibleText.CHARACTER:
 141           result = String.valueOf(text.charAt(index));
 142           break;
 143         case AccessibleText.WORD:
 144           startIndex = text.lastIndexOf(' ', index);
 145           endIndex = text.indexOf(' ', startIndex + 1);
 146           if (endIndex == -1)
 147             endIndex = startIndex + 1;
 148           result = text.substring(startIndex + 1, endIndex);
 149           break;
 150         case AccessibleText.SENTENCE:
 151         default:
 152           startIndex = text.lastIndexOf('.', index);
 153           endIndex = text.indexOf('.', startIndex + 1);
 154           if (endIndex == -1)
 155             endIndex = startIndex + 1;
 156           result = text.substring(startIndex + 1, endIndex);
 157           break;
 158         }
 159       return result;
 160     }
 161
 162     /**
 163      * Returns the character, word or sentence after the specified index. The
 164      * <code>part</code> parameter determines what is returned, the character,
 165      * word or sentence after the index.
 166      *
 167      * @param part one of {@link AccessibleText#CHARACTER},
 168      *             {@link AccessibleText#WORD} or
 169      *             {@link AccessibleText#SENTENCE}, specifying what is returned
 170      * @param index the index
 171      *
 172      * @return the character, word or sentence after <code>index</code>
 173      */
 174     public String getAfterIndex(int part, int index)
 175     {
 176       String result = "";
 177       int startIndex = -1;
 178       int endIndex = -1;
 179       switch(part)
 180         {
 181         case AccessibleText.CHARACTER:
 182           result = String.valueOf(text.charAt(index + 1));
 183           break;
 184         case AccessibleText.WORD:
 185           startIndex = text.indexOf(' ', index);
 186           endIndex = text.indexOf(' ', startIndex + 1);
 187           if (endIndex == -1)
 188             endIndex = startIndex + 1;
 189           result = text.substring(startIndex + 1, endIndex);
 190           break;
 191         case AccessibleText.SENTENCE:
 192         default:
 193           startIndex = text.indexOf('.', index);
 194           endIndex = text.indexOf('.', startIndex + 1);
 195           if (endIndex == -1)
 196             endIndex = startIndex + 1;
 197           result = text.substring(startIndex + 1, endIndex);
 198           break;
 199         }
 200       return result;
 201     }
 202
 203     /**
 204      * Returns the character, word or sentence before the specified index. The
 205      * <code>part</code> parameter determines what is returned, the character,
 206      * word or sentence before the index.
 207      *
 208      * @param part one of {@link AccessibleText#CHARACTER},
 209      *             {@link AccessibleText#WORD} or
 210      *             {@link AccessibleText#SENTENCE}, specifying what is returned
 211      * @param index the index
 212      *
 213      * @return the character, word or sentence before <code>index</code>
 214      */
 215     public String getBeforeIndex(int part, int index)
 216     {
 217       String result = "";
 218       int startIndex = -1;
 219       int endIndex = -1;
 220       switch(part)
 221         {
 222         case AccessibleText.CHARACTER:
 223           result = String.valueOf(text.charAt(index - 1));
 224           break;
 225         case AccessibleText.WORD:
 226           endIndex = text.lastIndexOf(' ', index);
 227           if (endIndex == -1)
 228             endIndex = 0;
 229           startIndex = text.lastIndexOf(' ', endIndex - 1);
 230           result = text.substring(startIndex + 1, endIndex);
 231           break;
 232         case AccessibleText.SENTENCE:
 233         default:
 234           endIndex = text.lastIndexOf('.', index);
 235           if (endIndex == -1)
 236             endIndex = 0;
 237           startIndex = text.lastIndexOf('.', endIndex - 1);
 238           result = text.substring(startIndex + 1, endIndex);
 239           break;
 240         }
 241       return result;
 242     }
 243
 244     /**
 245      * Returns the caret position. This method returns -1 because JLabel don't
 246      * have a caret.
 247      *
 248      * @return the caret position
 249      */
 250     public int getCaretPosition()
 251     {
 252       return -1;
 253     }
 254
 255     /**
 256      * Returns the number of characters that are displayed by the JLabel.
 257      *
 258      * @return the number of characters that are displayed by the JLabel
 259      */
 260     public int getCharCount()
 261     {
 262       return text.length();
 263     }
 264
 265     /**
 266      * Returns the bounding box of the character at the specified index.
 267      *
 268      * @param index the index of the character that we return the
 269      *        bounds for
 270      *
 271      * @return the bounding box of the character at the specified index
 272      */
 273     public Rectangle getCharacterBounds(int index)
 274     {
 275       // FIXME: Implement this correctly.
 276       return new Rectangle();
 277     }
 278
 279     /**
 280      * Returns the index of the character that is located at the specified
 281      * point.
 282      *
 283      * @param point the location that we lookup the character for
 284      *
 285      * @return the index of the character that is located at the specified
 286      *         point
 287      */
 288     public int getIndexAtPoint(Point point)
 289     {
 290       // FIXME: Implement this correctly.
 291       return 0;
 292     }
 293   }
 294
 295   /** DOCUMENT ME! */
 296   private static final long serialVersionUID = 5496508283662221534L;
 297
 298   /**
 299    * The Component the label will give focus to when its mnemonic is
 300    * activated.
 301    */
 302   protected Component labelFor;
 303
 304   /** The label's text. */
 305   transient String text;
 306
 307   /** Where the label will be positioned horizontally. */
 308   private transient int horizontalAlignment = LEADING;
 309
 310   /** Where the label text will be placed horizontally relative to the icon. */
 311   private transient int horizontalTextPosition = TRAILING;
 312
 313   /** Where the label will be positioned vertically. */
 314   private transient int verticalAlignment = CENTER;
 315
 316   /** Where the label text will be place vertically relative to the icon. */
 317   private transient int verticalTextPosition = CENTER;
 318
 319   /** The icon painted when the label is enabled. */
 320   private transient Icon icon;
 321
 322   /** The icon painted when the label is disabled. */
 323   private transient Icon disabledIcon;
 324
 325   /** The label's mnemnonic key. */
 326   private transient int displayedMnemonic = KeyEvent.VK_UNDEFINED;
 327
 328   /** The index of the menemonic character in the text. */
 329   private transient int displayedMnemonicIndex = -1;
 330
 331   /** The gap between the icon and the text. */
 332   private transient int iconTextGap = 4;
 333
 334   /**
 335    * Creates a new vertically centered, horizontally on the leading edge
 336    * JLabel object with text and no icon.
 337    */
 338   public JLabel()
 339   {
 340     this(null, null, LEADING);
 341   }
 342
 343   /**
 344    * Creates a new vertically and horizontally centered
 345    * JLabel object with no text and the given icon.
 346    *
 347    * @param image The icon to use with the label.
 348    */
 349   public JLabel(Icon image)
 350   {
 351     this(null, image, CENTER);
 352   }
 353
 354   /**
 355    * Creates a new vertically centered JLabel object with no text and the
 356    * given icon and horizontal alignment. By default, the text is TRAILING
 357    * the image.
 358    *
 359    * @param image The icon to use with the label.
 360    * @param horizontalAlignment The horizontal alignment of the label.
 361    */
 362   public JLabel(Icon image, int horizontalAlignment)
 363   {
 364     this(null, image, horizontalAlignment);
 365   }
 366
 367   /**
 368    * Creates a new horizontally leading and vertically centered JLabel
 369    * object with no icon and the given text.
 370    *
 371    * @param text The text to use with the label.
 372    */
 373   public JLabel(String text)
 374   {
 375     this(text, null, LEADING);
 376   }
 377
 378   /**
 379    * Creates a new vertically centered JLabel object with no icon and the
 380    * given text and horizontal alignment.
 381    *
 382    * @param text The text to use with the label.
 383    * @param horizontalAlignment The horizontal alignment of the label.
 384    */
 385   public JLabel(String text, int horizontalAlignment)
 386   {
 387     this(text, null, horizontalAlignment);
 388   }
 389
 390   /**
 391    * Creates a new vertically centered JLabel object with the given text,
 392    * icon, and horizontal alignment.
 393    *
 394    * @param text The text to use with the label.
 395    * @param icon The icon to use with the label.
 396    * @param horizontalAlignment The horizontal alignment of the label.
 397    */
 398   public JLabel(String text, Icon icon, int horizontalAlignment)
 399   {
 400     this.text = text;
 401     this.icon = icon;
 402     this.horizontalAlignment = horizontalAlignment;
 403     setAlignmentX(0.0F);
 404     updateUI();
 405   }
 406
 407   /**
 408    * This method returns the label's UI delegate.
 409    *
 410    * @return The label's UI delegate.
 411    */
 412   public LabelUI getUI()
 413   {
 414     return (LabelUI) ui;
 415   }
 416
 417   /**
 418    * This method sets the label's UI delegate.
 419    *
 420    * @param ui The label's UI delegate.
 421    */
 422   public void setUI(LabelUI ui)
 423   {
 424     super.setUI(ui);
 425   }
 426
 427   /**
 428    * This method resets the label's UI delegate to the default UI for the
 429    * current look and feel.
 430    */
 431   public void updateUI()
 432   {
 433     setUI((LabelUI) UIManager.getUI(this));
 434   }
 435
 436   /**
 437    * This method returns a name to identify which look and feel class will be
 438    * the UI delegate for this label.
 439    *
 440    * @return The UIClass identifier. "LabelUI"
 441    */
 442   public String getUIClassID()
 443   {
 444     return "LabelUI";
 445   }
 446
 447   /**
 448    * This method is used primarily for debugging purposes and returns a string
 449    * that can be used to represent this label.
 450    *
 451    * @return A string to represent this label.
 452    */
 453   protected String paramString()
 454   {
 455     return "JLabel";
 456   }
 457
 458   /**
 459    * This method returns the label text.
 460    *
 461    * @return The label text.
 462    */
 463   public String getText()
 464   {
 465     return text;
 466   }
 467
 468   /**
 469    * This method changes the "text" property. The given text will be painted
 470    * in the label.
 471    *
 472    * @param newText The label's text.
 473    */
 474   public void setText(String newText)
 475   {
 476     if (text != newText)
 477       {
 478         String oldText = text;
 479         text = newText;
 480         firePropertyChange("text", oldText, newText);
 481
 482         if (text != null && text.length() <= displayedMnemonicIndex)
 483           setDisplayedMnemonicIndex(text.length() - 1);
 484         revalidate();
 485         repaint();
 486       }
 487   }
 488
 489   /**
 490    * This method returns the active icon. The active icon is painted when the
 491    * label is enabled.
 492    *
 493    * @return The active icon.
 494    */
 495   public Icon getIcon()
 496   {
 497     return icon;
 498   }
 499
 500   /**
 501    * This method changes the "icon" property. This icon (the active icon) will
 502    * be the one displayed when the label is enabled.
 503    *
 504    * @param newIcon The active icon.
 505    */
 506   public void setIcon(Icon newIcon)
 507   {
 508     if (icon != newIcon)
 509       {
 510         Icon oldIcon = icon;
 511         icon = newIcon;
 512         firePropertyChange("icon", oldIcon, newIcon);
 513       }
 514   }
 515
 516   /**
 517    * This method returns the disabled icon. The disabled icon is painted when
 518    * the label is disabled. If the disabled icon is null and the active icon
 519    * is an ImageIcon, this method returns a grayed version of the icon. The
 520    * grayed  version of the icon becomes the disabledIcon.
 521    *
 522    * @return The disabled icon.
 523    */
 524   public Icon getDisabledIcon()
 525   {
 526     if (disabledIcon == null && icon instanceof ImageIcon)
 527       disabledIcon = new ImageIcon(GrayFilter.createDisabledImage(((ImageIcon) icon)
 528                                                                   .getImage()));
 529
 530     return disabledIcon;
 531   }
 532
 533   /**
 534    * This method changes the "disabledIcon" property. This icon (the disabled
 535    * icon) will be the one displayed when the label is disabled.
 536    *
 537    * @param newIcon The disabled icon.
 538    */
 539   public void setDisabledIcon(Icon newIcon)
 540   {
 541     if (disabledIcon != newIcon)
 542       {
 543         Icon oldIcon = disabledIcon;
 544         disabledIcon = newIcon;
 545         firePropertyChange("disabledIcon", oldIcon, newIcon);
 546       }
 547   }
 548
 549   /**
 550    * This method sets the keycode that will be the label's mnemonic. If the
 551    * label is used as a label for another component, the label will give
 552    * focus to that component when the mnemonic is activated.
 553    *
 554    * @param mnemonic The keycode to use for the mnemonic.
 555    */
 556   public void setDisplayedMnemonic(int mnemonic)
 557   {
 558     if (displayedMnemonic != mnemonic)
 559       {
 560         firePropertyChange("displayedMnemonic",
 561                            displayedMnemonic, mnemonic);
 562         displayedMnemonic = mnemonic;
 563
 564         if (text != null)
 565           setDisplayedMnemonicIndex(text.toUpperCase().indexOf(mnemonic));
 566       }
 567   }
 568
 569   /**
 570    * This method sets the character that will be the mnemonic used. If the
 571    * label is used as a label for another component, the label will give
 572    * focus to that component when the mnemonic is activated.
 573    *
 574    * @param mnemonic The character to use for the mnemonic.
 575    */
 576   public void setDisplayedMnemonic(char mnemonic)
 577   {
 578     setDisplayedMnemonic((int) Character.toUpperCase(mnemonic));
 579   }
 580
 581   /**
 582    * This method returns the keycode that is used for the label's mnemonic.
 583    *
 584    * @return The keycode that is used for the label's mnemonic.
 585    */
 586   public int getDisplayedMnemonic()
 587   {
 588     return (int) displayedMnemonic;
 589   }
 590
 591   /**
 592    * This method sets which character in the text will be the underlined
 593    * character. If the given index is -1, then this indicates  that there is
 594    * no mnemonic. If the index is less than -1 or if the index is equal to
 595    * the length, this method will throw an IllegalArgumentException.
 596    *
 597    * @param newIndex The index of the character to underline.
 598    *
 599    * @throws IllegalArgumentException If index less than -1 or index equals
 600    *         length.
 601    */
 602   public void setDisplayedMnemonicIndex(int newIndex)
 603     throws IllegalArgumentException
 604   {
 605     if (newIndex < -1 || (text != null && newIndex >= text.length()))
 606       throw new IllegalArgumentException();
 607
 608     if (newIndex == -1
 609         || text == null
 610         || text.charAt(newIndex) != displayedMnemonic)
 611       newIndex = -1;
 612
 613     if (newIndex != displayedMnemonicIndex)
 614       {
 615         int oldIndex = displayedMnemonicIndex;
 616         displayedMnemonicIndex = newIndex;
 617         firePropertyChange("displayedMnemonicIndex",
 618                            oldIndex, newIndex);
 619       }
 620   }
 621
 622   /**
 623    * This method returns which character in the text will be  the underlined
 624    * character.
 625    *
 626    * @return The index of the character that will be underlined.
 627    */
 628   public int getDisplayedMnemonicIndex()
 629   {
 630     return displayedMnemonicIndex;
 631   }
 632
 633   /**
 634    * This method ensures that the key is valid as a horizontal alignment.
 635    * Valid keys are: LEFT, CENTER, RIGHT, LEADING, TRAILING
 636    *
 637    * @param key The key to check.
 638    * @param message The message of the exception to be thrown if the key is
 639    *        invalid.
 640    *
 641    * @return The key if it's valid.
 642    *
 643    * @throws IllegalArgumentException If the key is invalid.
 644    */
 645   protected int checkHorizontalKey(int key, String message)
 646   {
 647     if (key != LEFT && key != CENTER && key != RIGHT && key != LEADING
 648         && key != TRAILING)
 649       throw new IllegalArgumentException(message);
 650     else
 651       return key;
 652   }
 653
 654   /**
 655    * This method ensures that the key is valid as a  vertical alignment. Valid
 656    * keys are: TOP, CENTER, and BOTTOM.
 657    *
 658    * @param key The key to check.
 659    * @param message The message of the exception to be thrown if the key is
 660    *        invalid.
 661    *
 662    * @return The key if it's valid.
 663    *
 664    * @throws IllegalArgumentException If the key is invalid.
 665    */
 666   protected int checkVerticalKey(int key, String message)
 667   {
 668     if (key != TOP && key != BOTTOM && key != CENTER)
 669       throw new IllegalArgumentException(message);
 670     else
 671       return key;
 672   }
 673
 674   /**
 675    * This method returns the gap between the icon and the text.
 676    *
 677    * @return The gap between the icon and the text.
 678    */
 679   public int getIconTextGap()
 680   {
 681     return iconTextGap;
 682   }
 683
 684   /**
 685    * This method changes the "iconTextGap" property. The iconTextGap
 686    * determines how much space there is between the icon and the text.
 687    *
 688    * @param newGap The gap between the icon and the text.
 689    */
 690   public void setIconTextGap(int newGap)
 691   {
 692     if (iconTextGap != newGap)
 693       {
 694         firePropertyChange("iconTextGap", iconTextGap, newGap);
 695         iconTextGap = newGap;
 696       }
 697   }
 698
 699   /**
 700    * This method returns the vertical alignment of the label.
 701    *
 702    * @return The vertical alignment of the label.
 703    */
 704   public int getVerticalAlignment()
 705   {
 706     return verticalAlignment;
 707   }
 708
 709   /**
 710    * This method changes the "verticalAlignment" property of the label. The
 711    * vertical alignment determines how where the label will be placed
 712    * vertically. If the alignment is not valid, it will default to the
 713    * center.
 714    *
 715    * @param alignment The vertical alignment of the label.
 716    */
 717   public void setVerticalAlignment(int alignment)
 718   {
 719     if (alignment == verticalAlignment)
 720       return;
 721
 722     int oldAlignment = verticalAlignment;
 723     verticalAlignment = checkVerticalKey(alignment, "verticalAlignment");
 724     firePropertyChange("verticalAlignment", oldAlignment, verticalAlignment);
 725   }
 726
 727   /**
 728    * This method returns the horziontal alignment of the label.
 729    *
 730    * @return The horizontal alignment of the label.
 731    */
 732   public int getHorizontalAlignment()
 733   {
 734     return horizontalAlignment;
 735   }
 736
 737   /**
 738    * This method changes the "horizontalAlignment" property. The horizontal
 739    * alignment determines where the label will be placed horizontally.
 740    *
 741    * @param alignment The horizontal alignment of the label.
 742    */
 743   public void setHorizontalAlignment(int alignment)
 744   {
 745     if (horizontalAlignment == alignment)
 746       return;
 747
 748     int oldAlignment = horizontalAlignment;
 749     horizontalAlignment = checkHorizontalKey(alignment, "horizontalAlignment");
 750     firePropertyChange("horizontalAlignment", oldAlignment,
 751                        horizontalAlignment);
 752   }
 753
 754   /**
 755    * This method returns the vertical text position of the label.
 756    *
 757    * @return The vertical text position of the label.
 758    */
 759   public int getVerticalTextPosition()
 760   {
 761     return verticalTextPosition;
 762   }
 763
 764   /**
 765    * This method changes the "verticalTextPosition" property of the label. The
 766    * vertical text position determines where the text will be placed
 767    * vertically relative to the icon.
 768    *
 769    * @param textPosition The vertical text position.
 770    */
 771   public void setVerticalTextPosition(int textPosition)
 772   {
 773     if (textPosition != verticalTextPosition)
 774       {
 775         int oldPos = verticalTextPosition;
 776         verticalTextPosition = checkVerticalKey(textPosition,
 777                                                 "verticalTextPosition");
 778         firePropertyChange("verticalTextPosition", oldPos,
 779                            verticalTextPosition);
 780       }
 781   }
 782
 783   /**
 784    * This method returns the horizontal text position of the label.
 785    *
 786    * @return The horizontal text position.
 787    */
 788   public int getHorizontalTextPosition()
 789   {
 790     return horizontalTextPosition;
 791   }
 792
 793   /**
 794    * This method changes the "horizontalTextPosition" property of the label.
 795    * The horizontal text position determines where the text will be placed
 796    * horizontally relative to the icon.
 797    *
 798    * @param textPosition The horizontal text position.
 799    */
 800   public void setHorizontalTextPosition(int textPosition)
 801   {
 802     if (textPosition != horizontalTextPosition)
 803       {
 804         int oldPos = horizontalTextPosition;
 805         horizontalTextPosition = checkHorizontalKey(textPosition,
 806                                                     "horizontalTextPosition");
 807         firePropertyChange("horizontalTextPosition", oldPos,
 808                            horizontalTextPosition);
 809       }
 810   }
 811
 812   /**
 813    * This method simply returns false if the current icon image (current  icon
 814    * will depend on whether the label is enabled) is not equal to the passed
 815    * in image.
 816    *
 817    * @param img The image to check.
 818    * @param infoflags The bitwise inclusive OR of ABORT, ALLBITS, ERROR,
 819    *        FRAMEBITS, HEIGHT, PROPERTIES, SOMEBITS, and WIDTH
 820    * @param x The x position
 821    * @param y The y position
 822    * @param w The width
 823    * @param h The height
 824    *
 825    * @return Whether the current icon image is equal to the image given.
 826    */
 827   public boolean imageUpdate(Image img, int infoflags, int x, int y, int w,
 828                              int h)
 829   {
 830     Icon currIcon = isEnabled() ? icon : disabledIcon;
 831
 832     // XXX: Is this the correct way to check for image equality?
 833     if (currIcon != null && currIcon instanceof ImageIcon)
 834       return (((ImageIcon) currIcon).getImage() == img);
 835
 836     return false;
 837   }
 838
 839   /**
 840    * This method returns the component that the label gives focus to  when the
 841    * mnemonic is activated.
 842    *
 843    * @return The component that gets focus when the label's mnemonic is
 844    *         activated.
 845    */
 846   public Component getLabelFor()
 847   {
 848     return labelFor;
 849   }
 850
 851   /**
 852    * This method changes the "labelFor" property. The component that the label
 853    * is acting as a label for will request focus when the label's  mnemonic
 854    * is activated.
 855    *
 856    * @param c The component that gets focus when the label's mnemonic is
 857    *        activated.
 858    */
 859   public void setLabelFor(Component c)
 860   {
 861     if (c != labelFor)
 862       {
 863         Component oldLabelFor = labelFor;
 864         labelFor = c;
 865         firePropertyChange("labelFor", oldLabelFor, labelFor);
 866       }
 867   }
 868
 869   /**
 870    * This method overrides setFont so that we can call for a repaint after the
 871    * font is changed.
 872    *
 873    * @param f The font for this label.
 874    */
 875   public void setFont(Font f)
 876   {
 877     super.setFont(f);
 878     repaint();
 879   }
 880
 881   /**
 882    * DOCUMENT ME!
 883    *
 884    * @return The accessible context.
 885    */
 886   public AccessibleContext getAccessibleContext()
 887   {
 888     if (accessibleContext == null)
 889       accessibleContext = new AccessibleJLabel();
 890     return accessibleContext;
 891   }
 892 }