001/* BasicLabelUI.java
002 Copyright (C) 2002, 2004, 2006, Free Software Foundation, Inc.
003
004 This file is part of GNU Classpath.
005
006 GNU Classpath is free software; you can redistribute it and/or modify
007 it under the terms of the GNU General Public License as published by
008 the Free Software Foundation; either version 2, or (at your option)
009 any later version.
010
011 GNU Classpath is distributed in the hope that it will be useful, but
012 WITHOUT ANY WARRANTY; without even the implied warranty of
013 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
014 General Public License for more details.
015
016 You should have received a copy of the GNU General Public License
017 along with GNU Classpath; see the file COPYING.  If not, write to the
018 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
019 02110-1301 USA.
020
021 Linking this library statically or dynamically with other modules is
022 making a combined work based on this library.  Thus, the terms and
023 conditions of the GNU General Public License cover the whole
024 combination.
025
026 As a special exception, the copyright holders of this library give you
027 permission to link this library with independent modules to produce an
028 executable, regardless of the license terms of these independent
029 modules, and to copy and distribute the resulting executable under
030 terms of your choice, provided that you also meet, for each linked
031 independent module, the terms and conditions of the license of that
032 module.  An independent module is a module which is not derived from
033 or based on this library.  If you modify this library, you may extend
034 this exception to your version of the library, but you are not
035 obligated to do so.  If you do not wish to do so, delete this
036 exception statement from your version. */
037
038package javax.swing.plaf.basic;
039
040import java.awt.Component;
041import java.awt.Dimension;
042import java.awt.Font;
043import java.awt.FontMetrics;
044import java.awt.Graphics;
045import java.awt.Insets;
046import java.awt.Rectangle;
047import java.awt.Toolkit;
048import java.awt.event.ActionEvent;
049import java.awt.event.KeyEvent;
050import java.beans.PropertyChangeEvent;
051import java.beans.PropertyChangeListener;
052
053import javax.swing.AbstractAction;
054import javax.swing.ActionMap;
055import javax.swing.Icon;
056import javax.swing.InputMap;
057import javax.swing.JComponent;
058import javax.swing.JLabel;
059import javax.swing.KeyStroke;
060import javax.swing.LookAndFeel;
061import javax.swing.SwingUtilities;
062import javax.swing.plaf.ComponentUI;
063import javax.swing.plaf.LabelUI;
064import javax.swing.text.View;
065
066/**
067 * This is the Basic Look and Feel class for the JLabel.  One BasicLabelUI
068 * object is used to paint all JLabels that utilize the Basic Look and Feel.
069 */
070public class BasicLabelUI extends LabelUI implements PropertyChangeListener
071{
072  /** The labelUI that is shared by all labels. */
073  protected static BasicLabelUI labelUI;
074
075  /**
076   * These fields hold the rectangles for the whole label,
077   * the icon and the text.
078   */
079  private Rectangle vr;
080  private Rectangle ir;
081  private Rectangle tr;
082
083  /**
084   * A cached Insets object for reuse in the label layout methods.
085   */
086  private Insets cachedInsets;
087
088  /**
089   * Creates a new BasicLabelUI object.
090   */
091  public BasicLabelUI()
092  {
093    super();
094    vr = new Rectangle();
095    ir = new Rectangle();
096    tr = new Rectangle();
097  }
098
099  /**
100   * Creates and returns a UI for the label. Since one UI is shared by  all
101   * labels, this means creating only if necessary and returning the  shared
102   * UI.
103   *
104   * @param c The {@link JComponent} that a UI is being created for.
105   *
106   * @return A label UI for the Basic Look and Feel.
107   */
108  public static ComponentUI createUI(JComponent c)
109  {
110    if (labelUI == null)
111      labelUI = new BasicLabelUI();
112    return labelUI;
113  }
114
115  /**
116   * Returns the preferred size of this component as calculated by the
117   * {@link #layoutCL(JLabel, FontMetrics, String, Icon, Rectangle, Rectangle,
118   * Rectangle)} method.
119   *
120   * @param c This {@link JComponent} to get a preferred size for.
121   *
122   * @return The preferred size.
123   */
124  public Dimension getPreferredSize(JComponent c)
125  {
126    JLabel lab = (JLabel) c;
127    Insets insets = lab.getInsets();
128    int insetsX = insets.left + insets.right;
129    int insetsY = insets.top + insets.bottom;
130    Icon icon = lab.getIcon();
131    String text = lab.getText();
132    Dimension ret;
133    if (icon == null && text == null)
134      ret = new Dimension(insetsX, insetsY);
135    else if (icon != null && text == null)
136      ret = new Dimension(icon.getIconWidth() + insetsX,
137                          icon.getIconHeight() + insetsY);
138    else
139      {
140        FontMetrics fm = getFontMetrics(lab);
141        ir.x = 0;
142        ir.y = 0;
143        ir.width = 0;
144        ir.height = 0;
145        tr.x = 0;
146        tr.y = 0;
147        tr.width = 0;
148        tr.height = 0;
149        vr.x = 0;
150        vr.y = 0;
151        vr.width = Short.MAX_VALUE;
152        vr.height = Short.MAX_VALUE;
153        layoutCL(lab, fm, text, icon, vr, ir, tr);
154        Rectangle cr = SwingUtilities.computeUnion(tr.x, tr.y, tr.width,
155                                                   tr.height, ir);
156        ret = new Dimension(cr.width + insetsX, cr.height + insetsY);
157      }
158    return ret;
159  }
160
161  /**
162   * This method returns the minimum size of the {@link JComponent} given. If
163   * this method returns null, then it is up to the Layout Manager to give
164   * this component a minimum size.
165   *
166   * @param c The {@link JComponent} to get a minimum size for.
167   *
168   * @return The minimum size.
169   */
170  public Dimension getMinimumSize(JComponent c)
171  {
172    return getPreferredSize(c);
173  }
174
175  /**
176   * This method returns the maximum size of the {@link JComponent} given. If
177   * this method returns null, then it is up to the Layout Manager to give
178   * this component a maximum size.
179   *
180   * @param c The {@link JComponent} to get a maximum size for.
181   *
182   * @return The maximum size.
183   */
184  public Dimension getMaximumSize(JComponent c)
185  {
186    return getPreferredSize(c);
187  }
188
189  /**
190   * The method that paints the label according to its current state.
191   *
192   * @param g The {@link Graphics} object to paint with.
193   * @param c The {@link JComponent} to paint.
194   */
195  public void paint(Graphics g, JComponent c)
196  {
197    JLabel b = (JLabel) c;
198    Icon icon = (b.isEnabled()) ? b.getIcon() : b.getDisabledIcon();
199    String text = b.getText();
200    if (icon != null || (text != null && ! text.equals("")))
201      {
202        FontMetrics fm = getFontMetrics(b);
203        Insets i = c.getInsets(cachedInsets);
204        vr.x = i.left;
205        vr.y = i.right;
206        vr.width = c.getWidth() - i.left - i.right;
207        vr.height = c.getHeight() - i.top - i.bottom;
208        ir.x = 0;
209        ir.y = 0;
210        ir.width = 0;
211        ir.height = 0;
212        tr.x = 0;
213        tr.y = 0;
214        tr.width = 0;
215        tr.height = 0;
216
217        text = layoutCL(b, fm, text, icon, vr, ir, tr);
218
219        if (icon != null)
220          icon.paintIcon(b, g, ir.x, ir.y);
221
222        if (text != null && ! text.equals(""))
223          {
224            Object htmlRenderer = b.getClientProperty(BasicHTML.propertyKey);
225            if (htmlRenderer == null)
226              {
227                if (b.isEnabled())
228                  paintEnabledText(b, g, text, tr.x, tr.y + fm.getAscent());
229                else
230                  paintDisabledText(b, g, text, tr.x, tr.y + fm.getAscent());
231              }
232            else
233              {
234                ((View) htmlRenderer).paint(g, tr);
235              }
236          }
237      }
238  }
239
240  /**
241   * This method is simply calls SwingUtilities's layoutCompoundLabel.
242   *
243   * @param label The label to lay out.
244   * @param fontMetrics The FontMetrics for the font used.
245   * @param text The text to paint.
246   * @param icon The icon to draw.
247   * @param viewR The entire viewable rectangle.
248   * @param iconR The icon bounds rectangle.
249   * @param textR The text bounds rectangle.
250   *
251   * @return A possibly clipped version of the text.
252   */
253  protected String layoutCL(JLabel label, FontMetrics fontMetrics, String text,
254      Icon icon, Rectangle viewR, Rectangle iconR, Rectangle textR)
255  {
256    return SwingUtilities.layoutCompoundLabel(label, fontMetrics, text, icon,
257        label.getVerticalAlignment(), label.getHorizontalAlignment(), label
258            .getVerticalTextPosition(), label.getHorizontalTextPosition(),
259        viewR, iconR, textR, label.getIconTextGap());
260  }
261
262  /**
263   * Paints the text if the label is disabled. By default, this paints the
264   * clipped text returned by layoutCompoundLabel using the
265   * background.brighter() color. It also paints the same text using the
266   * background.darker() color one pixel to the right and one pixel down.
267   *
268   * @param l The {@link JLabel} being painted.
269   * @param g The {@link Graphics} object to paint with.
270   * @param s The String to paint.
271   * @param textX The x coordinate of the start of the baseline.
272   * @param textY The y coordinate of the start of the baseline.
273   */
274  protected void paintDisabledText(JLabel l, Graphics g, String s, int textX,
275      int textY)
276  {
277    g.setColor(l.getBackground().brighter());
278
279    int mnemIndex = l.getDisplayedMnemonicIndex();
280
281    if (mnemIndex != -1)
282      BasicGraphicsUtils.drawStringUnderlineCharAt(g, s, mnemIndex, textX,
283          textY);
284    else
285      g.drawString(s, textX, textY);
286
287    g.setColor(l.getBackground().darker());
288    if (mnemIndex != -1)
289      BasicGraphicsUtils.drawStringUnderlineCharAt(g, s, mnemIndex, textX + 1,
290          textY + 1);
291    else
292      g.drawString(s, textX + 1, textY + 1);
293  }
294
295  /**
296   * Paints the text if the label is enabled. The text is painted using the
297   * foreground color.
298   *
299   * @param l The {@link JLabel} being painted.
300   * @param g The {@link Graphics} object to paint with.
301   * @param s The String to paint.
302   * @param textX The x coordinate of the start of the baseline.
303   * @param textY The y coordinate of the start of the baseline.
304   */
305  protected void paintEnabledText(JLabel l, Graphics g, String s, int textX,
306                                  int textY)
307  {
308    g.setColor(l.getForeground());
309
310    int mnemIndex = l.getDisplayedMnemonicIndex();
311
312    if (mnemIndex != -1)
313      BasicGraphicsUtils.drawStringUnderlineCharAt(g, s, mnemIndex, textX,
314          textY);
315    else
316      g.drawString(s, textX, textY);
317  }
318
319  /**
320   * This method installs the UI for the given {@link JComponent}.  This
321   * method will install the component, defaults, listeners,  and keyboard
322   * actions.
323   *
324   * @param c The {@link JComponent} that this UI is being installed on.
325   */
326  public void installUI(JComponent c)
327  {
328    super.installUI(c);
329    if (c instanceof JLabel)
330    {
331      JLabel l = (JLabel) c;
332
333      installComponents(l);
334      installDefaults(l);
335      installListeners(l);
336      installKeyboardActions(l);
337    }
338  }
339
340  /**
341   * This method uninstalls the UI for the given {@link JComponent}. This
342   * method will uninstall the component, defaults, listeners,  and keyboard
343   * actions.
344   *
345   * @param c The {@link JComponent} that this UI is being installed on.
346   */
347  public void uninstallUI(JComponent c)
348  {
349    super.uninstallUI(c);
350    if (c instanceof JLabel)
351    {
352      JLabel l = (JLabel) c;
353
354      uninstallKeyboardActions(l);
355      uninstallListeners(l);
356      uninstallDefaults(l);
357      uninstallComponents(l);
358    }
359  }
360
361  /**
362   * This method installs the components for this {@link JLabel}.
363   *
364   * @param c The {@link JLabel} to install components for.
365   */
366  protected void installComponents(JLabel c)
367  {
368    BasicHTML.updateRenderer(c, c.getText());
369  }
370
371  /**
372   * This method uninstalls the components for this {@link JLabel}.
373   *
374   * @param c The {@link JLabel} to uninstall components for.
375   */
376  protected void uninstallComponents(JLabel c)
377  {
378    c.putClientProperty(BasicHTML.propertyKey, null);
379    c.putClientProperty(BasicHTML.documentBaseKey, null);
380  }
381
382  /**
383   * This method installs the defaults that are defined in  the Basic look and
384   * feel for this {@link JLabel}.
385   *
386   * @param c The {@link JLabel} to install defaults for.
387   */
388  protected void installDefaults(JLabel c)
389  {
390    LookAndFeel.installColorsAndFont(c, "Label.background", "Label.foreground",
391                                     "Label.font");
392    //XXX: There are properties we don't use called disabledForeground
393    //and disabledShadow.
394  }
395
396  /**
397   * This method uninstalls the defaults that are defined in the Basic look
398   * and feel for this {@link JLabel}.
399   *
400   * @param c The {@link JLabel} to uninstall defaults for.
401   */
402  protected void uninstallDefaults(JLabel c)
403  {
404    c.setForeground(null);
405    c.setBackground(null);
406    c.setFont(null);
407  }
408
409  /**
410   * Installs the keyboard actions for the given {@link JLabel}.
411   *
412   * @param l The {@link JLabel} to install keyboard actions for.
413   */
414  protected void installKeyboardActions(JLabel l)
415  {
416    Component c = l.getLabelFor();
417    if (c != null)
418      {
419        int mnemonic = l.getDisplayedMnemonic();
420        if (mnemonic > 0)
421          {
422            // add a keystroke for the given mnemonic mapping to 'press';
423            InputMap keyMap = new InputMap();
424            keyMap.put(KeyStroke.getKeyStroke(mnemonic, KeyEvent.VK_ALT),
425                "press");
426            SwingUtilities.replaceUIInputMap(l,
427                JComponent.WHEN_IN_FOCUSED_WINDOW, keyMap);
428
429            // add an action to focus the component when 'press' happens
430            ActionMap map = new ActionMap();
431            map.put("press", new AbstractAction() {
432              public void actionPerformed(ActionEvent event)
433              {
434                JLabel label = (JLabel) event.getSource();
435                Component c = label.getLabelFor();
436                if (c != null)
437                  c.requestFocus();
438              }
439            });
440            SwingUtilities.replaceUIActionMap(l, map);
441          }
442      }
443  }
444
445  /**
446   * This method uninstalls the keyboard actions for the given {@link JLabel}.
447   *
448   * @param l The {@link JLabel} to uninstall keyboard actions for.
449   */
450  protected void uninstallKeyboardActions(JLabel l)
451  {
452    SwingUtilities.replaceUIActionMap(l, null);
453    SwingUtilities.replaceUIInputMap(l, JComponent.WHEN_IN_FOCUSED_WINDOW,
454                                     null);
455  }
456
457  /**
458   * This method installs the listeners for the  given {@link JLabel}. The UI
459   * delegate only listens to  the label.
460   *
461   * @param c The {@link JLabel} to install listeners for.
462   */
463  protected void installListeners(JLabel c)
464  {
465    c.addPropertyChangeListener(this);
466  }
467
468  /**
469   * This method uninstalls the listeners for the given {@link JLabel}. The UI
470   * delegate only listens to the label.
471   *
472   * @param c The {@link JLabel} to uninstall listeners for.
473   */
474  protected void uninstallListeners(JLabel c)
475  {
476    c.removePropertyChangeListener(this);
477  }
478
479  /**
480   * This method is called whenever any JLabel's that use this UI has one of
481   * their properties change.
482   *
483   * @param e The {@link PropertyChangeEvent} that describes the change.
484   */
485  public void propertyChange(PropertyChangeEvent e)
486  {
487    if (e.getPropertyName().equals("text"))
488      {
489        String text = (String) e.getNewValue();
490        JLabel l = (JLabel) e.getSource();
491        BasicHTML.updateRenderer(l, text);
492      }
493    else if (e.getPropertyName().equals("displayedMnemonic"))
494      {
495        // update the key to action mapping
496        JLabel label = (JLabel) e.getSource();
497        if (label.getLabelFor() != null)
498          {
499            int oldMnemonic = ((Integer) e.getOldValue()).intValue();
500            int newMnemonic = ((Integer) e.getNewValue()).intValue();
501            InputMap keyMap = label.getInputMap(
502                JComponent.WHEN_IN_FOCUSED_WINDOW);
503            keyMap.put(KeyStroke.getKeyStroke(oldMnemonic,
504                KeyEvent.ALT_DOWN_MASK), null);
505            keyMap.put(KeyStroke.getKeyStroke(newMnemonic,
506                KeyEvent.ALT_DOWN_MASK), "press");
507          }
508      }
509    else if (e.getPropertyName().equals("labelFor"))
510      {
511        JLabel label = (JLabel) e.getSource();
512        InputMap keyMap = label.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
513        int mnemonic = label.getDisplayedMnemonic();
514        if (mnemonic > 0)
515          keyMap.put(KeyStroke.getKeyStroke(mnemonic, KeyEvent.ALT_DOWN_MASK),
516              "press");
517      }
518  }
519
520  /**
521   * Fetches a font metrics object for the specified label. This first
522   * tries to get it from the label object itself by calling
523   * {@link Component#getFontMetrics(Font)}, and if that does not work
524   * (for instance, when we are in the initialization and have no parent yet),
525   * it asks the Toolkit for a font metrics object.
526   *
527   * @param l the label
528   *
529   * @return a suitable font metrics object
530   */
531  private FontMetrics getFontMetrics(JLabel l)
532  {
533    Font font = l.getFont();
534    FontMetrics fm = l.getFontMetrics(font);
535    if (fm == null)
536      {
537        Toolkit tk = Toolkit.getDefaultToolkit();
538        fm = tk.getFontMetrics(font);
539      }
540    return fm;
541  }
542}