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 */ getSelectedText()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 */ getSelectionStart()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 */ getSelectionEnd()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 */ getCharacterAttribute(int index)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 */ getAtIndex(int part, int index)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 */ getAfterIndex(int part, int index)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 */ getBeforeIndex(int part, int index)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 */ getCaretPosition()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 */ getCharCount()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 */ getCharacterBounds(int index)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 */ getIndexAtPoint(Point point)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 */ JLabel()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 */ JLabel(Icon image)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 */ JLabel(Icon image, int horizontalAlignment)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 */ JLabel(String text)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 */ JLabel(String text, int horizontalAlignment)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 */ JLabel(String text, Icon icon, int horizontalAlignment)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 */ getUI()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 */ setUI(LabelUI ui)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 */ updateUI()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 */ getUIClassID()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 */ paramString()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 */ getText()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 */ setText(String newText)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 */ getIcon()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 */ setIcon(Icon newIcon)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 */ getDisabledIcon()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 */ setDisabledIcon(Icon newIcon)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 */ setDisplayedMnemonic(int mnemonic)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 */ setDisplayedMnemonic(char mnemonic)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 */ getDisplayedMnemonic()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 */ setDisplayedMnemonicIndex(int newIndex)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 */ getDisplayedMnemonicIndex()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 */ checkHorizontalKey(int key, String message)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 */ checkVerticalKey(int key, String message)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 */ getIconTextGap()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 */ setIconTextGap(int newGap)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 */ getVerticalAlignment()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 */ setVerticalAlignment(int alignment)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 */ getHorizontalAlignment()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 */ setHorizontalAlignment(int alignment)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 */ getVerticalTextPosition()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 */ setVerticalTextPosition(int textPosition)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 */ getHorizontalTextPosition()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 */ setHorizontalTextPosition(int textPosition)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 */ imageUpdate(Image img, int infoflags, int x, int y, int w, int h)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 */ getLabelFor()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 */ setLabelFor(Component c)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 */ setFont(Font f)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 */ getAccessibleContext()886 public AccessibleContext getAccessibleContext() 887 { 888 if (accessibleContext == null) 889 accessibleContext = new AccessibleJLabel(); 890 return accessibleContext; 891 } 892 } 893