GNU Classpath (0.20) | |
Frames | No Frames |
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: }
GNU Classpath (0.20) |