![[UML diagram illustrating the architecture for pluggable
* look and feels]](doc-files/ComponentUI-1.png)
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 JSlider, the
* user interface would be provided by some concrete subclass of
* {@link javax.swing.plaf.SliderUI}.
*
*
Soon after its creation, a ComponentUI will be sent
* an {@link #installUI} message. The ComponentUI will
* react by setting properties such as the border or the background
* color of the JComponent for which it provides its
* services. Soon before the end of its lifecycle, the
* ComponentUI will receive an {@link #uninstallUI}
* message, at which time the ComponentUI is expected to
* undo any changes.
Note that the ui of a JComponent
* changes whenever the user switches between look and feels. For
* example, the ui property of a JSlider
* could change from an instance of MetalSliderUI to an
* instance of FooSliderUI. This switch can happen at any
* time, but it will always be performed from inside the Swing thread.
ComponentUI delegate is created.
* The delegate object then receives an installUI
* message.
*
* This method should perform the following tasks:
* *opaque property is false)
* before calling {@link #paint}.
*
* 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 null, which means that
* c’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 null to indicate that
* c’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 null to indicate that
* c’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 null to indicate that
* c’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 createUI method of a suitable
* subclass. The implementation of ComponentUI
* 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 c.
*
* @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 c.
*
* @param i the index of the accessible child, starting at zero.
*
* @param c the component whose i-th accessible child
* is requested.
*/
public Accessible getAccessibleChild(JComponent c, int i)
{
return c.getAccessibleContext().getAccessibleChild(i);
}
}