| /* ComponentUI.java -- |
| Copyright (C) 2002, 2003, 2004 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; |
| |
| import java.awt.Color; |
| import java.awt.Dimension; |
| import java.awt.Graphics; |
| |
| import javax.accessibility.Accessible; |
| import javax.swing.JComponent; |
| |
| /** |
| * The abstract base class for all delegates that provide the |
| * pluggable look and feel for Swing components. User applications |
| * should not need to access this class; it is internal to Swing |
| * and the look-and-feel implementations. |
| * |
| * <p><img src="doc-files/ComponentUI-1.png" width="700" height="550" |
| * alt="[UML diagram illustrating the architecture for pluggable |
| * look and feels]" /></p> |
| * |
| * <p>Components such as {@link javax.swing.JSlider} do not directly |
| * implement operations related to the look and feel of the user |
| * interface, such as painting or layout. Instead, they use a delegate |
| * object for all such tasks. In the case of <code>JSlider</code>, the |
| * user interface would be provided by some concrete subclass of |
| * {@link javax.swing.plaf.SliderUI}. |
| * |
| * <p>Soon after its creation, a <code>ComponentUI</code> will be sent |
| * an {@link #installUI} message. The <code>ComponentUI</code> will |
| * react by setting properties such as the border or the background |
| * color of the <code>JComponent</code> for which it provides its |
| * services. Soon before the end of its lifecycle, the |
| * <code>ComponentUI</code> will receive an {@link #uninstallUI} |
| * message, at which time the <code>ComponentUI</code> is expected to |
| * undo any changes.</p> |
| * |
| * <p>Note that the <code>ui</code> of a <code>JComponent</code> |
| * changes whenever the user switches between look and feels. For |
| * example, the <code>ui</code> property of a <code>JSlider</code> |
| * could change from an instance of <code>MetalSliderUI</code> to an |
| * instance of <code>FooSliderUI</code>. This switch can happen at any |
| * time, but it will always be performed from inside the Swing thread.</p> |
| * |
| * @author Sascha Brawer (brawer@dandelis.ch) |
| */ |
| public abstract class ComponentUI |
| { |
| /** |
| * Constructs a new UI delegate. |
| */ |
| public ComponentUI() |
| { |
| // Nothing to do here. |
| } |
| |
| |
| /** |
| * Sets up the specified component so it conforms the the design |
| * guidelines of the implemented look and feel. When the look and |
| * feel changes, a <code>ComponentUI</code> delegate is created. |
| * The delegate object then receives an <code>installUI</code> |
| * message. |
| * |
| * <p>This method should perform the following tasks:</p> |
| * |
| * <ul> |
| * <li>Set visual properties such as borders, fonts, colors, or |
| * icons. However, no change should be performed for those |
| * properties whose values have been directly set by the client |
| * application. To allow the distinction, LookAndFeels are expected |
| * to use values that implement the {@link UIResource} marker |
| * interface, such as {@link BorderUIResource} or {@link |
| * ColorUIResource}.</li> |
| * <li>If necessary, install a {@link java.awt.LayoutManager}.</li> |
| * <li>Embed custom sub-components. For instance, the UI delegate |
| * for a {@link javax.swing.JSplitPane} might install a special |
| * component for the divider.</li> |
| * <li>Register event listeners.</li> |
| * <li>Set up properties related to keyborad navigation, such as |
| * mnemonics or focus traversal policies.</li> |
| * </ul> |
| * |
| * @param c the component for which this delegate will provide |
| * services. |
| * |
| * @see #uninstallUI |
| * @see javax.swing.JComponent#setUI |
| * @see javax.swing.JComponent#updateUI |
| */ |
| public void installUI(JComponent c) |
| { |
| // The default implementation does not change any properties. |
| } |
| |
| |
| /** |
| * Puts the specified component into the state it had before |
| * {@link #installUI} was called. |
| * |
| * @param c the component for which this delegate has provided |
| * services. |
| * |
| * @see #installUI |
| * @see javax.swing.JComponent#setUI |
| * @see javax.swing.JComponent#updateUI |
| */ |
| public void uninstallUI(JComponent c) |
| { |
| // The default implementation does not change any properties. |
| } |
| |
| |
| /** |
| * Paints the component according to the design guidelines |
| * of the look and feel. Most subclasses will want to override |
| * this method. |
| * |
| * @param g the graphics for painting. |
| * |
| * @param c the component for which this delegate performs |
| * services. |
| */ |
| public void paint(Graphics g, JComponent c) |
| { |
| // Nothing is done here. This method is meant to be overridden by |
| // subclasses. |
| } |
| |
| |
| /** |
| * Fills the specified component with its background color |
| * (unless the <code>opaque</code> property is <code>false</code>) |
| * before calling {@link #paint}. |
| * |
| * <p>It is unlikely that a subclass needs to override this method. |
| * The actual rendering should be performed by the {@link #paint} |
| * method. |
| * |
| * @param g the graphics for painting. |
| * |
| * @param c the component for which this delegate performs |
| * services. |
| * |
| * @see #paint |
| * @see javax.swing.JComponent#paintComponent |
| */ |
| public void update(Graphics g, JComponent c) |
| { |
| if (c.isOpaque()) |
| { |
| Color oldColor = g.getColor(); |
| g.setColor(c.getBackground()); |
| g.fillRect(0, 0, c.getWidth(), c.getHeight()); |
| g.setColor(oldColor); |
| } |
| paint(g, c); |
| } |
| |
| /** |
| * Determines the preferred size of a component. The default |
| * implementation returns <code>null</code>, which means that |
| * <code>c</code>’s layout manager should be asked to |
| * calculate the preferred size. |
| * |
| * @param c the component for which this delegate performs services. |
| * |
| * @return the preferred size, or <code>null</code> to indicate that |
| * <code>c</code>’s layout manager should be asked |
| * for the preferred size. |
| */ |
| public Dimension getPreferredSize(JComponent c) |
| { |
| return null; |
| } |
| |
| |
| /** |
| * Determines the minimum size of a component. The default |
| * implementation calls {@link #getPreferredSize}, but subclasses |
| * might want to override this. |
| * |
| * @param c the component for which this delegate performs services. |
| * |
| * @return the minimum size, or <code>null</code> to indicate that |
| * <code>c</code>’s layout manager should be asked |
| * to calculate the minimum size. |
| */ |
| public Dimension getMinimumSize(JComponent c) |
| { |
| return getPreferredSize(c); |
| } |
| |
| |
| /** |
| * Determines the maximum size of a component. The default |
| * implementation calls {@link #getPreferredSize}, but subclasses |
| * might want to override this. |
| * |
| * @param c the component for which this delegate performs services. |
| * |
| * @return the maximum size, or <code>null</code> to indicate that |
| * <code>c</code>’s layout manager should be asked |
| * to calculate the maximum size. |
| */ |
| public Dimension getMaximumSize(JComponent c) |
| { |
| return getPreferredSize(c); |
| } |
| |
| |
| /** |
| * Determines whether a click into the component at a specified |
| * location is considered as having hit the component. The default |
| * implementation checks whether the point falls into the |
| * component’s bounding rectangle. Some subclasses might want |
| * to override this, for example in the case of a rounded button. |
| * |
| * @param c the component for which this delegate performs services. |
| * |
| * @param x the x coordinate of the point, relative to the local |
| * coordinate system of the component. Zero would be be |
| * component’s left edge, irrespective of the location |
| * inside its parent. |
| * |
| * @param y the y coordinate of the point, relative to the local |
| * coordinate system of the component. Zero would be be |
| * component’s top edge, irrespective of the location |
| * inside its parent. |
| */ |
| public boolean contains(JComponent c, int x, int y) |
| { |
| /* JComponent.contains calls the ui delegate for hit |
| * testing. Therefore, endless mutual recursion would result if we |
| * called c.contains(x, y) here. |
| * |
| * The previous Classpath implementation called the deprecated |
| * method java.awt.Component.inside. In the Sun implementation, it |
| * can be observed that inside, other than contains, does not call |
| * the ui delegate. But that inside() behaves different to |
| * contains() clearly is in violation of the method contract, and |
| * it is not something that a good implementation should rely upon |
| * -- even if Classpath ends up being forced to replicate this |
| * apparent bug of the Sun implementation. |
| */ |
| return (x >= 0) && (x < c.getWidth()) |
| && (y >= 0) && (y < c.getHeight()); |
| } |
| |
| |
| /** |
| * Creates a delegate object for the specified component. Users |
| * should use the <code>createUI</code> method of a suitable |
| * subclass. The implementation of <code>ComponentUI</code> |
| * always throws an error. |
| * |
| * @param c the component for which a UI delegate is requested. |
| */ |
| public static ComponentUI createUI(JComponent c) |
| { |
| throw new Error( |
| "javax.swing.plaf.ComponentUI does not implement createUI; call " |
| + "createUI on a subclass."); |
| } |
| |
| |
| /** |
| * Counts the number of accessible children in the component. The |
| * default implementation delegates the inquiry to the {@link |
| * javax.accessibility.AccessibleContext} of <code>c</code>. |
| * |
| * @param c the component whose accessible children |
| * are to be counted. |
| */ |
| public int getAccessibleChildrenCount(JComponent c) |
| { |
| return c.getAccessibleContext().getAccessibleChildrenCount(); |
| } |
| |
| |
| /** |
| * Returns the specified accessible child of the component. The |
| * default implementation delegates the inquiry to the {@link |
| * javax.accessibility.AccessibleContext} of <code>c</code>. |
| * |
| * @param i the index of the accessible child, starting at zero. |
| * |
| * @param c the component whose <code>i</code>-th accessible child |
| * is requested. |
| */ |
| public Accessible getAccessibleChild(JComponent c, int i) |
| { |
| return c.getAccessibleContext().getAccessibleChild(i); |
| } |
| } |
