BasicLabelUI.java

/* BasicLabelUI.java
 Copyright (C) 2002, 2004, 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.plaf.basic;

import java.awt.Component;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Insets;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;

import javax.swing.AbstractAction;
import javax.swing.ActionMap;
import javax.swing.Icon;
import javax.swing.InputMap;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.KeyStroke;
import javax.swing.LookAndFeel;
import javax.swing.SwingUtilities;
import javax.swing.plaf.ComponentUI;
import javax.swing.plaf.LabelUI;
import javax.swing.text.View;

/**
 * This is the Basic Look and Feel class for the JLabel.  One BasicLabelUI
 * object is used to paint all JLabels that utilize the Basic Look and Feel.
 */
public class BasicLabelUI extends LabelUI implements PropertyChangeListener
{
  /** The labelUI that is shared by all labels. */
  protected static BasicLabelUI labelUI;

  /**
   * These fields hold the rectangles for the whole label,
   * the icon and the text.
   */
  private Rectangle vr;
  private Rectangle ir;
  private Rectangle tr;

  /**
   * A cached Insets object for reuse in the label layout methods.
   */
  private Insets cachedInsets;

  /**
   * Creates a new BasicLabelUI object.
   */
  public BasicLabelUI()
  {
    super();
    vr = new Rectangle();
    ir = new Rectangle();
    tr = new Rectangle();
  }

  /**
   * Creates and returns a UI for the label. Since one UI is shared by  all
   * labels, this means creating only if necessary and returning the  shared
   * UI.
   *
   * @param c The {@link JComponent} that a UI is being created for.
   *
   * @return A label UI for the Basic Look and Feel.
   */
  public static ComponentUI createUI(JComponent c)
  {
    if (labelUI == null)
      labelUI = new BasicLabelUI();
    return labelUI;
  }

  /**
   * Returns the preferred size of this component as calculated by the
   * {@link #layoutCL(JLabel, FontMetrics, String, Icon, Rectangle, Rectangle, 
   * Rectangle)} method.
   *
   * @param c This {@link JComponent} to get a preferred size for.
   *
   * @return The preferred size.
   */
  public Dimension getPreferredSize(JComponent c)
  {
    JLabel lab = (JLabel) c;
    Insets insets = lab.getInsets();
    int insetsX = insets.left + insets.right;
    int insetsY = insets.top + insets.bottom;
    Icon icon = lab.getIcon();
    String text = lab.getText();
    Dimension ret;
    if (icon == null && text == null)
      ret = new Dimension(insetsX, insetsY);
    else if (icon != null && text == null)
      ret = new Dimension(icon.getIconWidth() + insetsX,
                          icon.getIconHeight() + insetsY);
    else
      {
        FontMetrics fm = getFontMetrics(lab);
        ir.x = 0;
        ir.y = 0;
        ir.width = 0;
        ir.height = 0;
        tr.x = 0;
        tr.y = 0;
        tr.width = 0;
        tr.height = 0;
        vr.x = 0;
        vr.y = 0;
        vr.width = Short.MAX_VALUE;
        vr.height = Short.MAX_VALUE;
        layoutCL(lab, fm, text, icon, vr, ir, tr);
        Rectangle cr = SwingUtilities.computeUnion(tr.x, tr.y, tr.width,
                                                   tr.height, ir);
        ret = new Dimension(cr.width + insetsX, cr.height + insetsY);
      }
    return ret;
  }

  /**
   * This method returns the minimum size of the {@link JComponent} given. If
   * this method returns null, then it is up to the Layout Manager to give
   * this component a minimum size.
   *
   * @param c The {@link JComponent} to get a minimum size for.
   *
   * @return The minimum size.
   */
  public Dimension getMinimumSize(JComponent c)
  {
    return getPreferredSize(c);
  }

  /**
   * This method returns the maximum size of the {@link JComponent} given. If
   * this method returns null, then it is up to the Layout Manager to give
   * this component a maximum size.
   *
   * @param c The {@link JComponent} to get a maximum size for.
   *
   * @return The maximum size.
   */
  public Dimension getMaximumSize(JComponent c)
  {
    return getPreferredSize(c);
  }

  /**
   * The method that paints the label according to its current state.
   * 
   * @param g The {@link Graphics} object to paint with.
   * @param c The {@link JComponent} to paint.
   */
  public void paint(Graphics g, JComponent c)
  {
    JLabel b = (JLabel) c;
    Icon icon = (b.isEnabled()) ? b.getIcon() : b.getDisabledIcon();
    String text = b.getText();
    if (icon != null || (text != null && ! text.equals("")))
      {
        FontMetrics fm = getFontMetrics(b);
        Insets i = c.getInsets(cachedInsets);
        vr.x = i.left;
        vr.y = i.right;
        vr.width = c.getWidth() - i.left - i.right;
        vr.height = c.getHeight() - i.top - i.bottom;
        ir.x = 0;
        ir.y = 0;
        ir.width = 0;
        ir.height = 0;
        tr.x = 0;
        tr.y = 0;
        tr.width = 0;
        tr.height = 0;

        text = layoutCL(b, fm, text, icon, vr, ir, tr);

        if (icon != null)
          icon.paintIcon(b, g, ir.x, ir.y);       

        if (text != null && ! text.equals(""))
          {
            Object htmlRenderer = b.getClientProperty(BasicHTML.propertyKey);
            if (htmlRenderer == null)
              {
                if (b.isEnabled())
                  paintEnabledText(b, g, text, tr.x, tr.y + fm.getAscent());
                else
                  paintDisabledText(b, g, text, tr.x, tr.y + fm.getAscent());
              }
            else
              {
                ((View) htmlRenderer).paint(g, tr);
              }
          }
      }
  }

  /**
   * This method is simply calls SwingUtilities's layoutCompoundLabel.
   * 
   * @param label The label to lay out.
   * @param fontMetrics The FontMetrics for the font used.
   * @param text The text to paint.
   * @param icon The icon to draw.
   * @param viewR The entire viewable rectangle.
   * @param iconR The icon bounds rectangle.
   * @param textR The text bounds rectangle.
   * 
   * @return A possibly clipped version of the text.
   */
  protected String layoutCL(JLabel label, FontMetrics fontMetrics, String text,
      Icon icon, Rectangle viewR, Rectangle iconR, Rectangle textR)
  {
    return SwingUtilities.layoutCompoundLabel(label, fontMetrics, text, icon,
        label.getVerticalAlignment(), label.getHorizontalAlignment(), label
            .getVerticalTextPosition(), label.getHorizontalTextPosition(),
        viewR, iconR, textR, label.getIconTextGap());
  }

  /**
   * Paints the text if the label is disabled. By default, this paints the
   * clipped text returned by layoutCompoundLabel using the
   * background.brighter() color. It also paints the same text using the
   * background.darker() color one pixel to the right and one pixel down.
   *
   * @param l The {@link JLabel} being painted.
   * @param g The {@link Graphics} object to paint with.
   * @param s The String to paint.
   * @param textX The x coordinate of the start of the baseline.
   * @param textY The y coordinate of the start of the baseline.
   */
  protected void paintDisabledText(JLabel l, Graphics g, String s, int textX,
      int textY)
  {
    g.setColor(l.getBackground().brighter());

    int mnemIndex = l.getDisplayedMnemonicIndex();

    if (mnemIndex != -1)
      BasicGraphicsUtils.drawStringUnderlineCharAt(g, s, mnemIndex, textX,
          textY);
    else
      g.drawString(s, textX, textY);

    g.setColor(l.getBackground().darker());
    if (mnemIndex != -1)
      BasicGraphicsUtils.drawStringUnderlineCharAt(g, s, mnemIndex, textX + 1,
          textY + 1);
    else
      g.drawString(s, textX + 1, textY + 1);
  }

  /**
   * Paints the text if the label is enabled. The text is painted using the
   * foreground color.
   *
   * @param l The {@link JLabel} being painted.
   * @param g The {@link Graphics} object to paint with.
   * @param s The String to paint.
   * @param textX The x coordinate of the start of the baseline.
   * @param textY The y coordinate of the start of the baseline.
   */
  protected void paintEnabledText(JLabel l, Graphics g, String s, int textX,
                                  int textY)
  {
    g.setColor(l.getForeground());

    int mnemIndex = l.getDisplayedMnemonicIndex();

    if (mnemIndex != -1)
      BasicGraphicsUtils.drawStringUnderlineCharAt(g, s, mnemIndex, textX,
          textY);
    else
      g.drawString(s, textX, textY);
  }

  /**
   * This method installs the UI for the given {@link JComponent}.  This
   * method will install the component, defaults, listeners,  and keyboard
   * actions.
   *
   * @param c The {@link JComponent} that this UI is being installed on.
   */
  public void installUI(JComponent c)
  {
    super.installUI(c);
    if (c instanceof JLabel)
    {
      JLabel l = (JLabel) c;

      installComponents(l);
      installDefaults(l);
      installListeners(l);
      installKeyboardActions(l);
    }
  }

  /**
   * This method uninstalls the UI for the given {@link JComponent}. This
   * method will uninstall the component, defaults, listeners,  and keyboard
   * actions.
   *
   * @param c The {@link JComponent} that this UI is being installed on.
   */
  public void uninstallUI(JComponent c)
  {
    super.uninstallUI(c);
    if (c instanceof JLabel)
    {
      JLabel l = (JLabel) c;

      uninstallKeyboardActions(l);
      uninstallListeners(l);
      uninstallDefaults(l);
      uninstallComponents(l);
    }
  }

  /**
   * This method installs the components for this {@link JLabel}.
   *
   * @param c The {@link JLabel} to install components for.
   */
  protected void installComponents(JLabel c)
  {
    BasicHTML.updateRenderer(c, c.getText());
  }

  /**
   * This method uninstalls the components for this {@link JLabel}.
   *
   * @param c The {@link JLabel} to uninstall components for.
   */
  protected void uninstallComponents(JLabel c)
  {
    c.putClientProperty(BasicHTML.propertyKey, null);
    c.putClientProperty(BasicHTML.documentBaseKey, null);
  }

  /**
   * This method installs the defaults that are defined in  the Basic look and
   * feel for this {@link JLabel}.
   *
   * @param c The {@link JLabel} to install defaults for.
   */
  protected void installDefaults(JLabel c)
  {
    LookAndFeel.installColorsAndFont(c, "Label.background", "Label.foreground",
                                     "Label.font");
    //XXX: There are properties we don't use called disabledForeground
    //and disabledShadow.
  }

  /**
   * This method uninstalls the defaults that are defined in the Basic look
   * and feel for this {@link JLabel}.
   *
   * @param c The {@link JLabel} to uninstall defaults for.
   */
  protected void uninstallDefaults(JLabel c)
  {
    c.setForeground(null);
    c.setBackground(null);
    c.setFont(null);
  }

  /**
   * Installs the keyboard actions for the given {@link JLabel}.
   *
   * @param l The {@link JLabel} to install keyboard actions for.
   */
  protected void installKeyboardActions(JLabel l)
  {
    Component c = l.getLabelFor();
    if (c != null)
      {
        int mnemonic = l.getDisplayedMnemonic();
        if (mnemonic > 0)
          {
            // add a keystroke for the given mnemonic mapping to 'press';
            InputMap keyMap = new InputMap();
            keyMap.put(KeyStroke.getKeyStroke(mnemonic, KeyEvent.VK_ALT), 
                "press");
            SwingUtilities.replaceUIInputMap(l, 
                JComponent.WHEN_IN_FOCUSED_WINDOW, keyMap);
            
            // add an action to focus the component when 'press' happens
            ActionMap map = new ActionMap();
            map.put("press", new AbstractAction() {
              public void actionPerformed(ActionEvent event)
              {
                JLabel label = (JLabel) event.getSource();
                Component c = label.getLabelFor();
                if (c != null)
                  c.requestFocus();
              }
            });
            SwingUtilities.replaceUIActionMap(l, map);
          }
      }   
  }

  /**
   * This method uninstalls the keyboard actions for the given {@link JLabel}.
   *
   * @param l The {@link JLabel} to uninstall keyboard actions for.
   */
  protected void uninstallKeyboardActions(JLabel l)
  {
    SwingUtilities.replaceUIActionMap(l, null);
    SwingUtilities.replaceUIInputMap(l, JComponent.WHEN_IN_FOCUSED_WINDOW, 
                                     null);
  }

  /**
   * This method installs the listeners for the  given {@link JLabel}. The UI
   * delegate only listens to  the label.
   *
   * @param c The {@link JLabel} to install listeners for.
   */
  protected void installListeners(JLabel c)
  {
    c.addPropertyChangeListener(this);
  }

  /**
   * This method uninstalls the listeners for the given {@link JLabel}. The UI
   * delegate only listens to the label.
   *
   * @param c The {@link JLabel} to uninstall listeners for.
   */
  protected void uninstallListeners(JLabel c)
  {
    c.removePropertyChangeListener(this);
  }

  /**
   * This method is called whenever any JLabel's that use this UI has one of
   * their properties change.
   *
   * @param e The {@link PropertyChangeEvent} that describes the change.
   */
  public void propertyChange(PropertyChangeEvent e)
  {
    if (e.getPropertyName().equals("text"))
      {
        String text = (String) e.getNewValue();
        JLabel l = (JLabel) e.getSource();
        BasicHTML.updateRenderer(l, text);
      }
    else if (e.getPropertyName().equals("displayedMnemonic"))
      {
        // update the key to action mapping
        JLabel label = (JLabel) e.getSource();
        if (label.getLabelFor() != null)
          {
            int oldMnemonic = ((Integer) e.getOldValue()).intValue();
            int newMnemonic = ((Integer) e.getNewValue()).intValue();
            InputMap keyMap = label.getInputMap(
                JComponent.WHEN_IN_FOCUSED_WINDOW);
            keyMap.put(KeyStroke.getKeyStroke(oldMnemonic, 
                KeyEvent.ALT_DOWN_MASK), null);
            keyMap.put(KeyStroke.getKeyStroke(newMnemonic, 
                KeyEvent.ALT_DOWN_MASK), "press");
          }
      }
    else if (e.getPropertyName().equals("labelFor"))
      {
        JLabel label = (JLabel) e.getSource();
        InputMap keyMap = label.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
        int mnemonic = label.getDisplayedMnemonic();
        if (mnemonic > 0)
          keyMap.put(KeyStroke.getKeyStroke(mnemonic, KeyEvent.ALT_DOWN_MASK), 
              "press");       
      }
  }

  /**
   * Fetches a font metrics object for the specified label. This first
   * tries to get it from the label object itself by calling
   * {@link Component#getFontMetrics(Font)}, and if that does not work
   * (for instance, when we are in the initialization and have no parent yet),
   * it asks the Toolkit for a font metrics object.
   *
   * @param l the label
   *
   * @return a suitable font metrics object
   */
  private FontMetrics getFontMetrics(JLabel l)
  {
    Font font = l.getFont();
    FontMetrics fm = l.getFontMetrics(font);
    if (fm == null)
      {
        Toolkit tk = Toolkit.getDefaultToolkit();
        fm = tk.getFontMetrics(font);
      }
    return fm;
  }
}