summaryrefslogtreecommitdiff
path: root/libjava/classpath/javax/swing/JLabel.java
diff options
context:
space:
mode:
Diffstat (limited to 'libjava/classpath/javax/swing/JLabel.java')
-rw-r--r--libjava/classpath/javax/swing/JLabel.java1122
1 files changed, 1122 insertions, 0 deletions
diff --git a/libjava/classpath/javax/swing/JLabel.java b/libjava/classpath/javax/swing/JLabel.java
new file mode 100644
index 000000000..72354c56e
--- /dev/null
+++ b/libjava/classpath/javax/swing/JLabel.java
@@ -0,0 +1,1122 @@
+/* JLabel.java --
+ Copyright (C) 2002, 2004, 2005, 2006, Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+
+package javax.swing;
+
+import gnu.java.lang.CPStringBuilder;
+
+import java.awt.Component;
+import java.awt.Font;
+import java.awt.FontMetrics;
+import java.awt.Image;
+import java.awt.Insets;
+import java.awt.Point;
+import java.awt.Rectangle;
+import java.awt.Shape;
+import java.awt.event.KeyEvent;
+import java.beans.PropertyChangeEvent;
+
+import javax.accessibility.Accessible;
+import javax.accessibility.AccessibleContext;
+import javax.accessibility.AccessibleExtendedComponent;
+import javax.accessibility.AccessibleRole;
+import javax.accessibility.AccessibleText;
+import javax.swing.plaf.LabelUI;
+import javax.swing.plaf.basic.BasicHTML;
+import javax.swing.text.AttributeSet;
+import javax.swing.text.BadLocationException;
+import javax.swing.text.Position;
+import javax.swing.text.SimpleAttributeSet;
+import javax.swing.text.View;
+
+/**
+ * A component that displays a static text message and/or an icon.
+ */
+public class JLabel extends JComponent implements Accessible, SwingConstants
+{
+
+ /**
+ * Provides the accessibility features for the <code>JLabel</code>
+ * component.
+ */
+ protected class AccessibleJLabel
+ extends JComponent.AccessibleJComponent
+ implements AccessibleText, AccessibleExtendedComponent
+ {
+
+ /**
+ * Returns the accessible name.
+ *
+ * @return The accessible name.
+ */
+ public String getAccessibleName()
+ {
+ if (accessibleName != null)
+ return accessibleName;
+ if (text != null)
+ return text;
+ else
+ return super.getAccessibleName();
+ }
+
+ /**
+ * Returns the accessible role for the <code>JLabel</code> component.
+ *
+ * @return {@link AccessibleRole#LABEL}.
+ */
+ public AccessibleRole getAccessibleRole()
+ {
+ return AccessibleRole.LABEL;
+ }
+
+ /**
+ * Returns the selected text. This is null since JLabels
+ * are not selectable.
+ *
+ * @return <code>null</code> because JLabels cannot have selected text
+ */
+ public String getSelectedText()
+ {
+ // We return null here since JLabel's text is not selectable.
+ return null;
+ }
+
+ /**
+ * Returns the start index of the selected text.
+ *
+ * @return the start index of the selected text
+ */
+ public int getSelectionStart()
+ {
+ // JLabel don't have selected text, so we return -1 here.
+ return -1;
+ }
+
+ /**
+ * Returns the end index of the selected text.
+ *
+ * @return the end index of the selected text
+ */
+ public int getSelectionEnd()
+ {
+ // JLabel don't have selected text, so we return -1 here.
+ return -1;
+ }
+
+ /**
+ * Returns an {@link AttributeSet} that reflects the text attributes of
+ * the specified character. We return an empty
+ * <code>AttributeSet</code> here, because JLabels don't support text
+ * attributes (at least not yet).
+ *
+ * @param index the index of the character
+ *
+ * @return an {@link AttributeSet} that reflects the text attributes of
+ * the specified character
+ */
+ public AttributeSet getCharacterAttribute(int index)
+ {
+ // FIXME: Return null here for simple labels, and query the HTML
+ // view for HTML labels.
+ return new SimpleAttributeSet();
+ }
+
+ /**
+ * Returns the character, word or sentence at the specified index. The
+ * <code>part</code> parameter determines what is returned, the character,
+ * word or sentence after the index.
+ *
+ * @param part one of {@link AccessibleText#CHARACTER},
+ * {@link AccessibleText#WORD} or
+ * {@link AccessibleText#SENTENCE}, specifying what is returned
+ * @param index the index
+ *
+ * @return the character, word or sentence after <code>index</code>
+ */
+ public String getAtIndex(int part, int index)
+ {
+ String result = "";
+ int startIndex = -1;
+ int endIndex = -1;
+ switch(part)
+ {
+ case AccessibleText.CHARACTER:
+ result = String.valueOf(text.charAt(index));
+ break;
+ case AccessibleText.WORD:
+ startIndex = text.lastIndexOf(' ', index);
+ endIndex = text.indexOf(' ', startIndex + 1);
+ if (endIndex == -1)
+ endIndex = startIndex + 1;
+ result = text.substring(startIndex + 1, endIndex);
+ break;
+ case AccessibleText.SENTENCE:
+ default:
+ startIndex = text.lastIndexOf('.', index);
+ endIndex = text.indexOf('.', startIndex + 1);
+ if (endIndex == -1)
+ endIndex = startIndex + 1;
+ result = text.substring(startIndex + 1, endIndex);
+ break;
+ }
+ return result;
+ }
+
+ /**
+ * Returns the character, word or sentence after the specified index. The
+ * <code>part</code> parameter determines what is returned, the character,
+ * word or sentence after the index.
+ *
+ * @param part one of {@link AccessibleText#CHARACTER},
+ * {@link AccessibleText#WORD} or
+ * {@link AccessibleText#SENTENCE}, specifying what is returned
+ * @param index the index
+ *
+ * @return the character, word or sentence after <code>index</code>
+ */
+ public String getAfterIndex(int part, int index)
+ {
+ String result = "";
+ int startIndex = -1;
+ int endIndex = -1;
+ switch(part)
+ {
+ case AccessibleText.CHARACTER:
+ result = String.valueOf(text.charAt(index + 1));
+ break;
+ case AccessibleText.WORD:
+ startIndex = text.indexOf(' ', index);
+ endIndex = text.indexOf(' ', startIndex + 1);
+ if (endIndex == -1)
+ endIndex = startIndex + 1;
+ result = text.substring(startIndex + 1, endIndex);
+ break;
+ case AccessibleText.SENTENCE:
+ default:
+ startIndex = text.indexOf('.', index);
+ endIndex = text.indexOf('.', startIndex + 1);
+ if (endIndex == -1)
+ endIndex = startIndex + 1;
+ result = text.substring(startIndex + 1, endIndex);
+ break;
+ }
+ return result;
+ }
+
+ /**
+ * Returns the character, word or sentence before the specified index. The
+ * <code>part</code> parameter determines what is returned, the character,
+ * word or sentence before the index.
+ *
+ * @param part one of {@link AccessibleText#CHARACTER},
+ * {@link AccessibleText#WORD} or
+ * {@link AccessibleText#SENTENCE}, specifying what is returned
+ * @param index the index
+ *
+ * @return the character, word or sentence before <code>index</code>
+ */
+ public String getBeforeIndex(int part, int index)
+ {
+ String result = "";
+ int startIndex = -1;
+ int endIndex = -1;
+ switch(part)
+ {
+ case AccessibleText.CHARACTER:
+ result = String.valueOf(text.charAt(index - 1));
+ break;
+ case AccessibleText.WORD:
+ endIndex = text.lastIndexOf(' ', index);
+ if (endIndex == -1)
+ endIndex = 0;
+ startIndex = text.lastIndexOf(' ', endIndex - 1);
+ result = text.substring(startIndex + 1, endIndex);
+ break;
+ case AccessibleText.SENTENCE:
+ default:
+ endIndex = text.lastIndexOf('.', index);
+ if (endIndex == -1)
+ endIndex = 0;
+ startIndex = text.lastIndexOf('.', endIndex - 1);
+ result = text.substring(startIndex + 1, endIndex);
+ break;
+ }
+ return result;
+ }
+
+ /**
+ * Returns the caret position. This method returns -1 because JLabel don't
+ * have a caret.
+ *
+ * @return the caret position
+ */
+ public int getCaretPosition()
+ {
+ return -1;
+ }
+
+ /**
+ * Returns the number of characters that are displayed by the JLabel.
+ *
+ * @return the number of characters that are displayed by the JLabel
+ */
+ public int getCharCount()
+ {
+ // FIXME: Query HTML view for HTML labels.
+ return text.length();
+ }
+
+ /**
+ * Returns the bounding box of the character at the specified index.
+ *
+ * @param index the index of the character that we return the
+ * bounds for
+ *
+ * @return the bounding box of the character at the specified index
+ */
+ public Rectangle getCharacterBounds(int index)
+ {
+ Rectangle bounds = null;
+ View view = (View) getClientProperty(BasicHTML.propertyKey);
+ if (view != null)
+ {
+ Rectangle textR = getTextRectangle();
+ try
+ {
+ Shape s = view.modelToView(index, textR, Position.Bias.Forward);
+ bounds = s.getBounds();
+ }
+ catch (BadLocationException ex)
+ {
+ // Can't return something reasonable in this case.
+ }
+ }
+ return bounds;
+ }
+
+ /**
+ * Returns the rectangle inside the JLabel, in which the actual text is
+ * rendered. This method has been adopted from the Mauve testcase
+ * gnu.testlet.javax.swing.JLabel.AccessibleJLabel.getCharacterBounds.
+ *
+ * @return the rectangle inside the JLabel, in which the actual text is
+ * rendered
+ */
+ private Rectangle getTextRectangle()
+ {
+ JLabel l = JLabel.this;
+ Rectangle textR = new Rectangle();
+ Rectangle iconR = new Rectangle();
+ Insets i = l.getInsets();
+ int w = l.getWidth();
+ int h = l.getHeight();
+ Rectangle viewR = new Rectangle(i.left, i.top, w - i.left - i.right,
+ h - i.top - i.bottom);
+ FontMetrics fm = l.getFontMetrics(l.getFont());
+ SwingUtilities.layoutCompoundLabel(l, fm, l.getText(), l.getIcon(),
+ l.getVerticalAlignment(),
+ l.getHorizontalAlignment(),
+ l.getVerticalTextPosition(),
+ l.getHorizontalTextPosition(),
+ viewR, iconR, textR,
+ l.getIconTextGap());
+ return textR;
+ }
+
+ /**
+ * Returns the index of the character that is located at the specified
+ * point.
+ *
+ * @param point the location that we lookup the character for
+ *
+ * @return the index of the character that is located at the specified
+ * point
+ */
+ public int getIndexAtPoint(Point point)
+ {
+ int index = -1;
+ View view = (View) getClientProperty(BasicHTML.propertyKey);
+ if (view != null)
+ {
+ Rectangle r = getTextRectangle();
+ index = view.viewToModel(point.x, point.y, r, new Position.Bias[0]);
+ }
+ return index;
+ }
+ }
+
+ private static final long serialVersionUID = 5496508283662221534L;
+
+ static final String LABEL_PROPERTY = "labeledBy";
+
+ /**
+ * The Component the label will give focus to when its mnemonic is
+ * activated.
+ */
+ protected Component labelFor;
+
+ /** The label's text. */
+ transient String text;
+
+ /** Where the label will be positioned horizontally. */
+ private transient int horizontalAlignment = LEADING;
+
+ /** Where the label text will be placed horizontally relative to the icon. */
+ private transient int horizontalTextPosition = TRAILING;
+
+ /** Where the label will be positioned vertically. */
+ private transient int verticalAlignment = CENTER;
+
+ /** Where the label text will be place vertically relative to the icon. */
+ private transient int verticalTextPosition = CENTER;
+
+ /** The icon painted when the label is enabled. */
+ private transient Icon icon;
+
+ /** The icon painted when the label is disabled. */
+ private transient Icon disabledIcon;
+
+ /** The label's mnemnonic key. */
+ private transient int displayedMnemonic = KeyEvent.VK_UNDEFINED;
+
+ /** The index of the mnemonic character in the text. */
+ private transient int displayedMnemonicIndex = -1;
+
+ /** The gap between the icon and the text. */
+ private transient int iconTextGap = 4;
+
+ /**
+ * Creates a new vertically centered, horizontally on the leading edge
+ * JLabel object with text and no icon.
+ */
+ public JLabel()
+ {
+ this("", null, LEADING);
+ }
+
+ /**
+ * Creates a new vertically and horizontally centered
+ * JLabel object with no text and the given icon.
+ *
+ * @param image The icon to use with the label, <code>null</code> permitted.
+ */
+ public JLabel(Icon image)
+ {
+ this(null, image, CENTER);
+ }
+
+ /**
+ * Creates a new vertically centered JLabel object with no text and the
+ * given icon and horizontal alignment. By default, the text is TRAILING
+ * the image.
+ *
+ * @param image The icon to use with the label, <code>null</code> premitted.
+ * @param horizontalAlignment The horizontal alignment of the label, must be
+ * either <code>CENTER</code>, <code>LEFT</code>, <code>RIGHT</code>,
+ * <code>LEADING</code> or <code>TRAILING</code>.
+ */
+ public JLabel(Icon image, int horizontalAlignment)
+ {
+ this(null, image, horizontalAlignment);
+ }
+
+ /**
+ * Creates a new horizontally leading and vertically centered JLabel
+ * object with no icon and the given text.
+ *
+ * @param text The text to use with the label, <code>null</code> permitted.
+ */
+ public JLabel(String text)
+ {
+ this(text, null, LEADING);
+ }
+
+ /**
+ * Creates a new vertically centered JLabel object with no icon and the
+ * given text and horizontal alignment.
+ *
+ * @param text The text to use with the label, <code>null</code> permitted.
+ * @param horizontalAlignment The horizontal alignment of the label, must be
+ * either <code>CENTER</code>, <code>LEFT</code>, <code>RIGHT</code>,
+ * <code>LEADING</code> or <code>TRAILING</code>.
+ */
+ public JLabel(String text, int horizontalAlignment)
+ {
+ this(text, null, horizontalAlignment);
+ }
+
+ /**
+ * Creates a new vertically centered JLabel object with the given text,
+ * icon, and horizontal alignment.
+ *
+ * @param text The text to use with the label, <code>null</code> permitted.
+ * @param icon The icon to use with the label, <code>null</code> premitted.
+ * @param horizontalAlignment The horizontal alignment of the label, must be
+ * either <code>CENTER</code>, <code>LEFT</code>, <code>RIGHT</code>,
+ * <code>LEADING</code> or <code>TRAILING</code>.
+ */
+ public JLabel(String text, Icon icon, int horizontalAlignment)
+ {
+ if (horizontalAlignment != SwingConstants.LEFT
+ && horizontalAlignment != SwingConstants.RIGHT
+ && horizontalAlignment != SwingConstants.CENTER
+ && horizontalAlignment != SwingConstants.LEADING
+ && horizontalAlignment != SwingConstants.TRAILING)
+ throw new IllegalArgumentException();
+
+ this.text = text;
+ this.icon = icon;
+ this.horizontalAlignment = horizontalAlignment;
+ setAlignmentX(0.0F);
+ setInheritsPopupMenu(true);
+ updateUI();
+ }
+
+ /**
+ * Returns the label's UI delegate.
+ *
+ * @return The label's UI delegate.
+ */
+ public LabelUI getUI()
+ {
+ return (LabelUI) ui;
+ }
+
+ /**
+ * Sets the label's UI delegate.
+ *
+ * @param ui The label's UI delegate (<code>null</code> not permitted).
+ */
+ public void setUI(LabelUI ui)
+ {
+ super.setUI(ui);
+ }
+
+ /**
+ * Resets the label's UI delegate to the default UI for the current look and
+ * feel.
+ */
+ public void updateUI()
+ {
+ setUI((LabelUI) UIManager.getUI(this));
+ }
+
+ /**
+ * Returns a name to identify which look and feel class will be
+ * the UI delegate for this label.
+ *
+ * @return <code>"LabelUI"</code>
+ */
+ public String getUIClassID()
+ {
+ return "LabelUI";
+ }
+
+ /**
+ * Returns a string describing the attributes for the <code>JLabel</code>
+ * component, for use in debugging. The return value is guaranteed to be
+ * non-<code>null</code>, but the format of the string may vary between
+ * implementations.
+ *
+ * @return A string describing the attributes of the <code>JLabel</code>.
+ */
+ protected String paramString()
+ {
+ CPStringBuilder sb = new CPStringBuilder(super.paramString());
+ sb.append(",defaultIcon=");
+ if (icon != null)
+ sb.append(icon);
+ sb.append(",disabledIcon=");
+ if (disabledIcon != null)
+ sb.append(disabledIcon);
+ sb.append(",horizontalAlignment=");
+ sb.append(SwingUtilities.convertHorizontalAlignmentCodeToString(
+ horizontalAlignment));
+ sb.append(",horizontalTextPosition=");
+ sb.append(SwingUtilities.convertHorizontalAlignmentCodeToString(
+ horizontalTextPosition));
+ sb.append(",iconTextGap=").append(iconTextGap);
+ sb.append(",labelFor=");
+ if (labelFor != null)
+ sb.append(labelFor);
+ sb.append(",text=");
+ if (text != null)
+ sb.append(text);
+ sb.append(",verticalAlignment=");
+ sb.append(SwingUtilities.convertVerticalAlignmentCodeToString(
+ verticalAlignment));
+ sb.append(",verticalTextPosition=");
+ sb.append(SwingUtilities.convertVerticalAlignmentCodeToString(
+ verticalTextPosition));
+ return sb.toString();
+ }
+
+ /**
+ * Returns the text displayed by the label.
+ *
+ * @return The label text (possibly <code>null</code>).
+ *
+ * @see #setText(String)
+ */
+ public String getText()
+ {
+ return text;
+ }
+
+ /**
+ * Sets the text for the label and sends a {@link PropertyChangeEvent} (with
+ * the name 'text') to all registered listeners. This method will also
+ * update the <code>displayedMnemonicIndex</code>, if necessary.
+ *
+ * @param newText The text (<code>null</code> permitted).
+ *
+ * @see #getText()
+ * @see #getDisplayedMnemonicIndex()
+ */
+ public void setText(String newText)
+ {
+ if (text == null && newText == null)
+ return;
+ if (text != null && text.equals(newText))
+ return;
+
+ String oldText = text;
+ text = newText;
+ firePropertyChange("text", oldText, newText);
+
+ if (text != null)
+ setDisplayedMnemonicIndex(text.toUpperCase().indexOf(displayedMnemonic));
+ else
+ setDisplayedMnemonicIndex(-1);
+ revalidate();
+ repaint();
+ }
+
+ /**
+ * Returns the active icon. The active icon is painted when the label is
+ * enabled.
+ *
+ * @return The active icon.
+ *
+ * @see #setIcon(Icon)
+ * @see #getDisabledIcon()
+ */
+ public Icon getIcon()
+ {
+ return icon;
+ }
+
+ /**
+ * Sets the icon for the label (this is a bound property with the name
+ * 'icon'). This icon will be displayed when the label is enabled.
+ *
+ * @param newIcon The icon (<code>null</code> permitted).
+ *
+ * @see #getIcon()
+ * @see #setDisabledIcon(Icon)
+ */
+ public void setIcon(Icon newIcon)
+ {
+ if (icon != newIcon)
+ {
+ Icon oldIcon = icon;
+ icon = newIcon;
+ firePropertyChange("icon", oldIcon, newIcon);
+ repaint();
+ }
+ }
+
+ /**
+ * Returns the disabled icon. The disabled icon is painted when the label is
+ * disabled. If the disabled icon is <code>null</code> and the active icon
+ * is an {@link ImageIcon}, this method returns a grayed version of the icon.
+ * The grayed version of the icon becomes the <code>disabledIcon</code>.
+ *
+ * @return The disabled icon.
+ *
+ * @see #setDisabledIcon(Icon)
+ */
+ public Icon getDisabledIcon()
+ {
+ if (disabledIcon == null && icon instanceof ImageIcon)
+ disabledIcon = new ImageIcon(
+ GrayFilter.createDisabledImage(((ImageIcon) icon).getImage()));
+
+ return disabledIcon;
+ }
+
+ /**
+ * Sets the icon displayed when the label is disabled (this is a bound
+ * property with the name 'disabledIcon').
+ *
+ * @param newIcon The disabled icon (<code>null</code> permitted).
+ *
+ * @see #getDisabledIcon()
+ */
+ public void setDisabledIcon(Icon newIcon)
+ {
+ if (disabledIcon != newIcon)
+ {
+ Icon oldIcon = disabledIcon;
+ disabledIcon = newIcon;
+ firePropertyChange("disabledIcon", oldIcon, newIcon);
+ }
+ }
+
+ /**
+ * Sets the keycode that will be the label's mnemonic (this is a bound
+ * property with the name 'displayedMnemonic'). If the label is used as a
+ * label for another component, the label will give focus to that component
+ * when the mnemonic is activated.
+ *
+ * @param mnemonic The keycode to use for the mnemonic.
+ *
+ * @see #getDisplayedMnemonic()
+ */
+ public void setDisplayedMnemonic(int mnemonic)
+ {
+ if (displayedMnemonic != mnemonic)
+ {
+ int old = displayedMnemonic;
+ displayedMnemonic = mnemonic;
+ firePropertyChange("displayedMnemonic", old, displayedMnemonic);
+ if (text != null)
+ setDisplayedMnemonicIndex(text.toUpperCase().indexOf(mnemonic));
+ }
+ }
+
+ /**
+ * Sets the character that will be the label's mnemonic. If the
+ * label is used as a label for another component, the label will give
+ * focus to that component when the mnemonic is activated via the keyboard.
+ *
+ * @param mnemonic The character to use for the mnemonic (this will be
+ * converted to the equivalent upper case character).
+ *
+ * @see #getDisplayedMnemonic()
+ */
+ public void setDisplayedMnemonic(char mnemonic)
+ {
+ setDisplayedMnemonic((int) Character.toUpperCase(mnemonic));
+ }
+
+ /**
+ * Returns the keycode that is used for the label's mnemonic.
+ *
+ * @return The keycode that is used for the label's mnemonic.
+ *
+ * @see #setDisplayedMnemonic(int)
+ */
+ public int getDisplayedMnemonic()
+ {
+ return displayedMnemonic;
+ }
+
+ /**
+ * Sets the index of the character in the text that will be underlined to
+ * indicate that it is the mnemonic character for the label. You only need
+ * to call this method if you wish to override the automatically calculated
+ * character index. For instance, for a label "Find Next" with the mnemonic
+ * character 'n', you might wish to underline the second occurrence of 'n'
+ * rather than the first (which is the default).
+ * <br><br>
+ * Note that this method does not validate the character at the specified
+ * index to ensure that it matches the key code returned by
+ * {@link #getDisplayedMnemonic()}.
+ *
+ * @param newIndex The index of the character to underline.
+ *
+ * @throws IllegalArgumentException If index less than -1 or index is greater
+ * than or equal to the label length.
+ *
+ * @see #getDisplayedMnemonicIndex()
+ * @since 1.4
+ */
+ public void setDisplayedMnemonicIndex(int newIndex)
+ throws IllegalArgumentException
+ {
+ int maxValid = -1;
+ if (text != null)
+ maxValid = text.length() - 1;
+ if (newIndex < -1 || newIndex > maxValid)
+ throw new IllegalArgumentException();
+
+ if (newIndex != displayedMnemonicIndex)
+ {
+ int oldIndex = displayedMnemonicIndex;
+ displayedMnemonicIndex = newIndex;
+ firePropertyChange("displayedMnemonicIndex", oldIndex, newIndex);
+ }
+ }
+
+ /**
+ * Returns the index of the character in the label's text that will be
+ * underlined (to indicate that it is the mnemonic character), or -1 if no
+ * character is to be underlined.
+ *
+ * @return The index of the character that will be underlined.
+ *
+ * @see #setDisplayedMnemonicIndex(int)
+ * @since 1.4
+ */
+ public int getDisplayedMnemonicIndex()
+ {
+ return displayedMnemonicIndex;
+ }
+
+ /**
+ * Checks the specified key to ensure that it is valid as a horizontal
+ * alignment, throwing an {@link IllegalArgumentException} if the key is
+ * invalid. Valid keys are {@link #LEFT}, {@link #CENTER}, {@link #RIGHT},
+ * {@link #LEADING} and {@link #TRAILING}.
+ *
+ * @param key The key to check.
+ * @param message The message of the exception to be thrown if the key is
+ * invalid.
+ *
+ * @return The key if it is valid.
+ *
+ * @throws IllegalArgumentException If the key is invalid.
+ */
+ protected int checkHorizontalKey(int key, String message)
+ {
+ if (key != LEFT && key != CENTER && key != RIGHT && key != LEADING
+ && key != TRAILING)
+ throw new IllegalArgumentException(message);
+ else
+ return key;
+ }
+
+ /**
+ * Checks the specified key to ensure that it is valid as a vertical
+ * alignment, throwing an {@link IllegalArgumentException} if the key is
+ * invalid. Valid keys are {@link #TOP}, {@link #CENTER} and {@link #BOTTOM}.
+ *
+ * @param key The key to check.
+ * @param message The message of the exception to be thrown if the key is
+ * invalid.
+ *
+ * @return The key if it is valid.
+ *
+ * @throws IllegalArgumentException If the key is invalid.
+ */
+ protected int checkVerticalKey(int key, String message)
+ {
+ if (key != TOP && key != BOTTOM && key != CENTER)
+ throw new IllegalArgumentException(message);
+ else
+ return key;
+ }
+
+ /**
+ * Returns the gap between the icon and the text.
+ *
+ * @return The gap between the icon and the text.
+ *
+ * @see #setIconTextGap(int)
+ */
+ public int getIconTextGap()
+ {
+ return iconTextGap;
+ }
+
+ /**
+ * Sets the gap between the icon and the text, in the case that both are
+ * visible (this is a bound property with the name 'iconTextGap').
+ *
+ * @param newGap The gap (in pixels).
+ *
+ * @see #getIconTextGap()
+ */
+ public void setIconTextGap(int newGap)
+ {
+ if (iconTextGap != newGap)
+ {
+ firePropertyChange("iconTextGap", iconTextGap, newGap);
+ iconTextGap = newGap;
+ }
+ }
+
+ /**
+ * Returns the vertical alignment of the label (one of
+ * {@link #TOP}, {@link #CENTER} and {@link #BOTTOM}). The default value
+ * depends on the installed look and feel, but is usually {@link #CENTER}.
+ *
+ * @return The vertical alignment.
+ *
+ * @see #setVerticalAlignment(int)
+ */
+ public int getVerticalAlignment()
+ {
+ return verticalAlignment;
+ }
+
+ /**
+ * Sets the vertical alignment for the label (this is a bound property with
+ * the name 'verticalAlignment'). The vertical alignment determines where
+ * the label (icon and text) will be placed vertically within the component
+ * bounds. Valid alignment codes are {@link #TOP}, {@link #CENTER} and
+ * {@link #BOTTOM}.
+ *
+ * @param alignment The vertical alignment of the label.
+ *
+ * @throws IllegalArgumentException if <code>alignment</code> is not one of
+ * the specified values.
+ *
+ * @see #getVerticalAlignment()
+ */
+ public void setVerticalAlignment(int alignment)
+ {
+ if (alignment == verticalAlignment)
+ return;
+
+ int oldAlignment = verticalAlignment;
+ verticalAlignment = checkVerticalKey(alignment, "verticalAlignment");
+ firePropertyChange("verticalAlignment", oldAlignment, verticalAlignment);
+ }
+
+ /**
+ * Returns the horizontal alignment of the label (one of {@link #LEFT},
+ * {@link #CENTER}, {@link #RIGHT}, {@link #LEADING} and {@link #TRAILING}).
+ * The default value depends on the installed look and feel, but is usually
+ * {@link #LEFT}.
+ *
+ * @return The horizontal alignment.
+ *
+ * @see #setHorizontalAlignment(int)
+ */
+ public int getHorizontalAlignment()
+ {
+ return horizontalAlignment;
+ }
+
+ /**
+ * Sets the horizontal alignment for the label (this is a bound property with
+ * the name 'horizontalAlignment'). The horizontal alignment determines where
+ * the label (icon and text) will be placed horizontally within the
+ * component bounds. Valid alignment codes are {@link #LEFT},
+ * {@link #CENTER}, {@link #RIGHT}, {@link #LEADING} and {@link #TRAILING}.
+ *
+ * @param alignment The horizontal alignment of the label.
+ *
+ * @throws IllegalArgumentException if <code>alignment</code> is not one of
+ * the specified values.
+ *
+ * @see #getHorizontalAlignment()
+ */
+ public void setHorizontalAlignment(int alignment)
+ {
+ if (horizontalAlignment == alignment)
+ return;
+
+ int oldAlignment = horizontalAlignment;
+ horizontalAlignment = checkHorizontalKey(alignment, "horizontalAlignment");
+ firePropertyChange("horizontalAlignment", oldAlignment,
+ horizontalAlignment);
+ }
+
+ /**
+ * Returns the vertical position of the label's text relative to the icon.
+ * This will be one of {@link #TOP}, {@link #CENTER} and {@link #BOTTOM}.
+ *
+ * @return The vertical position of the label's text relative to the icon.
+ *
+ * @see #setVerticalTextPosition(int)
+ */
+ public int getVerticalTextPosition()
+ {
+ return verticalTextPosition;
+ }
+
+ /**
+ * Sets the vertical position of the label's text relative to the icon (this
+ * is a bound property with the name 'verticalTextPosition'). Valid
+ * positions are {@link #TOP}, {@link #CENTER} and {@link #BOTTOM}.
+ *
+ * @param textPosition The vertical text position.
+ *
+ * @throws IllegalArgumentException if <code>textPosition</code> is not one
+ * of the specified values.
+ */
+ public void setVerticalTextPosition(int textPosition)
+ {
+ if (textPosition != verticalTextPosition)
+ {
+ int oldPos = verticalTextPosition;
+ verticalTextPosition = checkVerticalKey(textPosition,
+ "verticalTextPosition");
+ firePropertyChange("verticalTextPosition", oldPos,
+ verticalTextPosition);
+ }
+ }
+
+ /**
+ * Returns the horizontal position of the label's text relative to the icon.
+ * This will be one of {@link #LEFT}, {@link #CENTER}, {@link #RIGHT},
+ * {@link #LEADING} and {@link #TRAILING}.
+ *
+ * @return The horizontal position of the label's text relative to the icon.
+ *
+ * @see #setHorizontalTextPosition(int)
+ */
+ public int getHorizontalTextPosition()
+ {
+ return horizontalTextPosition;
+ }
+
+ /**
+ * Sets the horizontal position of the label's text relative to the icon (this
+ * is a bound property with the name 'horizontalTextPosition'). Valid
+ * positions are {@link #LEFT}, {@link #CENTER}, {@link #RIGHT},
+ * {@link #LEADING} and {@link #TRAILING}.
+ *
+ * @param textPosition The horizontal text position.
+ *
+ * @throws IllegalArgumentException if <code>textPosition</code> is not one
+ * of the specified values.
+ */
+ public void setHorizontalTextPosition(int textPosition)
+ {
+ if (textPosition != horizontalTextPosition)
+ {
+ int oldPos = horizontalTextPosition;
+ horizontalTextPosition = checkHorizontalKey(textPosition,
+ "horizontalTextPosition");
+ firePropertyChange("horizontalTextPosition", oldPos,
+ horizontalTextPosition);
+ }
+ }
+
+ /**
+ * Returns false if the current icon image (current icon will depend on
+ * whether the label is enabled) is not equal to the passed in image.
+ *
+ * @param img The image to check.
+ * @param infoflags The bitwise inclusive OR of ABORT, ALLBITS, ERROR,
+ * FRAMEBITS, HEIGHT, PROPERTIES, SOMEBITS, and WIDTH
+ * @param x The x position
+ * @param y The y position
+ * @param w The width
+ * @param h The height
+ *
+ * @return Whether the current icon image is equal to the image given.
+ */
+ public boolean imageUpdate(Image img, int infoflags, int x, int y, int w,
+ int h)
+ {
+ Icon currIcon = isEnabled() ? icon : disabledIcon;
+
+ // XXX: Is this the correct way to check for image equality?
+ if (currIcon != null && currIcon instanceof ImageIcon)
+ return (((ImageIcon) currIcon).getImage() == img);
+
+ return false;
+ }
+
+ /**
+ * Returns the component that this <code>JLabel</code> is providing the label
+ * for. This component will typically receive the focus when the label's
+ * mnemonic key is activated via the keyboard.
+ *
+ * @return The component (possibly <code>null</code>).
+ */
+ public Component getLabelFor()
+ {
+ return labelFor;
+ }
+
+ /**
+ * Sets the component that this <code>JLabel</code> is providing the label
+ * for (this is a bound property with the name 'labelFor'). This component
+ * will typically receive the focus when the label's mnemonic key is
+ * activated via the keyboard.
+ *
+ * @param c the component (<code>null</code> permitted).
+ *
+ * @see #getLabelFor()
+ */
+ public void setLabelFor(Component c)
+ {
+ if (c != labelFor)
+ {
+ Component oldLabelFor = labelFor;
+ labelFor = c;
+ firePropertyChange("labelFor", oldLabelFor, labelFor);
+
+ // We put the label into the client properties for the labeled
+ // component so that it can be read by the AccessibleJComponent.
+ // The other option would be to reserve a default visible field
+ // in JComponent, but since this is relatively seldomly used, it
+ // would be unnecessary waste of memory to do so.
+ if (oldLabelFor instanceof JComponent)
+ {
+ ((JComponent) oldLabelFor).putClientProperty(LABEL_PROPERTY, null);
+ }
+
+ if (labelFor instanceof JComponent)
+ {
+ ((JComponent) labelFor).putClientProperty(LABEL_PROPERTY, this);
+ }
+
+ }
+ }
+
+ /**
+ * Sets the font for the label (this a bound property with the name 'font').
+ *
+ * @param f The font (<code>null</code> permitted).
+ */
+ public void setFont(Font f)
+ {
+ super.setFont(f);
+ repaint();
+ }
+
+ /**
+ * Returns the object that provides accessibility features for this
+ * <code>JLabel</code> component.
+ *
+ * @return The accessible context (an instance of {@link AccessibleJLabel}).
+ */
+ public AccessibleContext getAccessibleContext()
+ {
+ if (accessibleContext == null)
+ accessibleContext = new AccessibleJLabel();
+ return accessibleContext;
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-09-15 21:21:55 +0000