GNU Classpath (0.19) | ||
Frames | No Frames |
1: /* ComponentUI.java -- 2: Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc. 3: 4: This file is part of GNU Classpath. 5: 6: GNU Classpath is free software; you can redistribute it and/or modify 7: it under the terms of the GNU General Public License as published by 8: the Free Software Foundation; either version 2, or (at your option) 9: any later version. 10: 11: GNU Classpath is distributed in the hope that it will be useful, but 12: WITHOUT ANY WARRANTY; without even the implied warranty of 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14: General Public License for more details. 15: 16: You should have received a copy of the GNU General Public License 17: along with GNU Classpath; see the file COPYING. If not, write to the 18: Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 19: 02110-1301 USA. 20: 21: Linking this library statically or dynamically with other modules is 22: making a combined work based on this library. Thus, the terms and 23: conditions of the GNU General Public License cover the whole 24: combination. 25: 26: As a special exception, the copyright holders of this library give you 27: permission to link this library with independent modules to produce an 28: executable, regardless of the license terms of these independent 29: modules, and to copy and distribute the resulting executable under 30: terms of your choice, provided that you also meet, for each linked 31: independent module, the terms and conditions of the license of that 32: module. An independent module is a module which is not derived from 33: or based on this library. If you modify this library, you may extend 34: this exception to your version of the library, but you are not 35: obligated to do so. If you do not wish to do so, delete this 36: exception statement from your version. */ 37: 38: 39: package javax.swing.plaf; 40: 41: import java.awt.Dimension; 42: import java.awt.Graphics; 43: import java.awt.Rectangle; 44: 45: import javax.accessibility.Accessible; 46: import javax.swing.JComponent; 47: 48: /** 49: * The abstract base class for all delegates that provide the 50: * pluggable look and feel for Swing components. User applications 51: * should not need to access this class; it is internal to Swing 52: * and the look-and-feel implementations. 53: * 54: * <p><img src="doc-files/ComponentUI-1.png" width="700" height="550" 55: * alt="[UML diagram illustrating the architecture for pluggable 56: * look and feels]" /></p> 57: * 58: * <p>Components such as {@link javax.swing.JSlider} do not directly 59: * implement operations related to the look and feel of the user 60: * interface, such as painting or layout. Instead, they use a delegate 61: * object for all such tasks. In the case of <code>JSlider</code>, the 62: * user interface would be provided by some concrete subclass of 63: * {@link javax.swing.plaf.SliderUI}. 64: * 65: * <p>Soon after its creation, a <code>ComponentUI</code> will be sent 66: * an {@link #installUI} message. The <code>ComponentUI</code> will 67: * react by setting properties such as the border or the background 68: * color of the <code>JComponent</code> for which it provides its 69: * services. Soon before the end of its lifecycle, the 70: * <code>ComponentUI</code> will receive an {@link #uninstallUI} 71: * message, at which time the <code>ComponentUI</code> is expected to 72: * undo any changes.</p> 73: * 74: * <p>Note that the <code>ui</code> of a <code>JComponent</code> 75: * changes whenever the user switches between look and feels. For 76: * example, the <code>ui</code> property of a <code>JSlider</code> 77: * could change from an instance of <code>MetalSliderUI</code> to an 78: * instance of <code>FooSliderUI</code>. This switch can happen at any 79: * time, but it will always be performed from inside the Swing thread.</p> 80: * 81: * @author Sascha Brawer (brawer@dandelis.ch) 82: */ 83: public abstract class ComponentUI 84: { 85: /** 86: * Constructs a new UI delegate. 87: */ 88: public ComponentUI() 89: { 90: // Nothing to do here. 91: } 92: 93: 94: /** 95: * Sets up the specified component so it conforms the the design 96: * guidelines of the implemented look and feel. When the look and 97: * feel changes, a <code>ComponentUI</code> delegate is created. 98: * The delegate object then receives an <code>installUI</code> 99: * message. 100: * 101: * <p>This method should perform the following tasks:</p> 102: * 103: * <ul> 104: * <li>Set visual properties such as borders, fonts, colors, or 105: * icons. However, no change should be performed for those 106: * properties whose values have been directly set by the client 107: * application. To allow the distinction, LookAndFeels are expected 108: * to use values that implement the {@link UIResource} marker 109: * interface, such as {@link BorderUIResource} or {@link 110: * ColorUIResource}.</li> 111: * <li>If necessary, install a {@link java.awt.LayoutManager}.</li> 112: * <li>Embed custom sub-components. For instance, the UI delegate 113: * for a {@link javax.swing.JSplitPane} might install a special 114: * component for the divider.</li> 115: * <li>Register event listeners.</li> 116: * <li>Set up properties related to keyborad navigation, such as 117: * mnemonics or focus traversal policies.</li> 118: * </ul> 119: * 120: * @param c the component for which this delegate will provide 121: * services. 122: * 123: * @see #uninstallUI 124: * @see javax.swing.JComponent#setUI 125: * @see javax.swing.JComponent#updateUI 126: */ 127: public void installUI(JComponent c) 128: { 129: // The default implementation does not change any properties. 130: } 131: 132: 133: /** 134: * Puts the specified component into the state it had before 135: * {@link #installUI} was called. 136: * 137: * @param c the component for which this delegate has provided 138: * services. 139: * 140: * @see #installUI 141: * @see javax.swing.JComponent#setUI 142: * @see javax.swing.JComponent#updateUI 143: */ 144: public void uninstallUI(JComponent c) 145: { 146: // The default implementation does not change any properties. 147: } 148: 149: 150: /** 151: * Paints the component according to the design guidelines 152: * of the look and feel. Most subclasses will want to override 153: * this method. 154: * 155: * @param g the graphics for painting. 156: * 157: * @param c the component for which this delegate performs 158: * services. 159: */ 160: public void paint(Graphics g, JComponent c) 161: { 162: // Nothing is done here. This method is meant to be overridden by 163: // subclasses. 164: } 165: 166: 167: /** 168: * Fills the specified component with its background color 169: * (unless the <code>opaque</code> property is <code>false</code>) 170: * before calling {@link #paint}. 171: * 172: * <p>It is unlikely that a subclass needs to override this method. 173: * The actual rendering should be performed by the {@link #paint} 174: * method. 175: * 176: * @param g the graphics for painting. 177: * 178: * @param c the component for which this delegate performs 179: * services. 180: * 181: * @see #paint 182: * @see javax.swing.JComponent#paintComponent 183: */ 184: public void update(Graphics g, JComponent c) 185: { 186: if (c.isOpaque()) 187: { 188: g.setColor(c.getBackground()); 189: Rectangle clip = g.getClipBounds(); 190: g.fillRect(0, 0, c.getWidth(), c.getHeight()); 191: } 192: paint(g, c); 193: } 194: 195: /** 196: * Determines the preferred size of a component. The default 197: * implementation returns <code>null</code>, which means that 198: * <code>c</code>’s layout manager should be asked to 199: * calculate the preferred size. 200: * 201: * @param c the component for which this delegate performs services. 202: * 203: * @return the preferred size, or <code>null</code> to indicate that 204: * <code>c</code>’s layout manager should be asked 205: * for the preferred size. 206: */ 207: public Dimension getPreferredSize(JComponent c) 208: { 209: return null; 210: } 211: 212: 213: /** 214: * Determines the minimum size of a component. The default 215: * implementation calls {@link #getPreferredSize}, but subclasses 216: * might want to override this. 217: * 218: * @param c the component for which this delegate performs services. 219: * 220: * @return the minimum size, or <code>null</code> to indicate that 221: * <code>c</code>’s layout manager should be asked 222: * to calculate the minimum size. 223: */ 224: public Dimension getMinimumSize(JComponent c) 225: { 226: return getPreferredSize(c); 227: } 228: 229: 230: /** 231: * Determines the maximum size of a component. The default 232: * implementation calls {@link #getPreferredSize}, but subclasses 233: * might want to override this. 234: * 235: * @param c the component for which this delegate performs services. 236: * 237: * @return the maximum size, or <code>null</code> to indicate that 238: * <code>c</code>’s layout manager should be asked 239: * to calculate the maximum size. 240: */ 241: public Dimension getMaximumSize(JComponent c) 242: { 243: return getPreferredSize(c); 244: } 245: 246: 247: /** 248: * Determines whether a click into the component at a specified 249: * location is considered as having hit the component. The default 250: * implementation checks whether the point falls into the 251: * component’s bounding rectangle. Some subclasses might want 252: * to override this, for example in the case of a rounded button. 253: * 254: * @param c the component for which this delegate performs services. 255: * 256: * @param x the x coordinate of the point, relative to the local 257: * coordinate system of the component. Zero would be be 258: * component’s left edge, irrespective of the location 259: * inside its parent. 260: * 261: * @param y the y coordinate of the point, relative to the local 262: * coordinate system of the component. Zero would be be 263: * component’s top edge, irrespective of the location 264: * inside its parent. 265: */ 266: public boolean contains(JComponent c, int x, int y) 267: { 268: /* JComponent.contains calls the ui delegate for hit 269: * testing. Therefore, endless mutual recursion would result if we 270: * called c.contains(x, y) here. 271: * 272: * The previous Classpath implementation called the deprecated 273: * method java.awt.Component.inside. In the Sun implementation, it 274: * can be observed that inside, other than contains, does not call 275: * the ui delegate. But that inside() behaves different to 276: * contains() clearly is in violation of the method contract, and 277: * it is not something that a good implementation should rely upon 278: * -- even if Classpath ends up being forced to replicate this 279: * apparent bug of the Sun implementation. 280: */ 281: return (x >= 0) && (x < c.getWidth()) 282: && (y >= 0) && (y < c.getHeight()); 283: } 284: 285: 286: /** 287: * Creates a delegate object for the specified component. Users 288: * should use the <code>createUI</code> method of a suitable 289: * subclass. The implementation of <code>ComponentUI</code> 290: * always throws an error. 291: * 292: * @param c the component for which a UI delegate is requested. 293: */ 294: public static ComponentUI createUI(JComponent c) 295: { 296: throw new Error( 297: "javax.swing.plaf.ComponentUI does not implement createUI; call " 298: + "createUI on a subclass."); 299: } 300: 301: 302: /** 303: * Counts the number of accessible children in the component. The 304: * default implementation delegates the inquiry to the {@link 305: * javax.accessibility.AccessibleContext} of <code>c</code>. 306: * 307: * @param c the component whose accessible children 308: * are to be counted. 309: */ 310: public int getAccessibleChildrenCount(JComponent c) 311: { 312: return c.getAccessibleContext().getAccessibleChildrenCount(); 313: } 314: 315: 316: /** 317: * Returns the specified accessible child of the component. The 318: * default implementation delegates the inquiry to the {@link 319: * javax.accessibility.AccessibleContext} of <code>c</code>. 320: * 321: * @param i the index of the accessible child, starting at zero. 322: * 323: * @param c the component whose <code>i</code>-th accessible child 324: * is requested. 325: */ 326: public Accessible getAccessibleChild(JComponent c, int i) 327: { 328: return c.getAccessibleContext().getAccessibleChild(i); 329: } 330: }
GNU Classpath (0.19) |