| GNU Classpath (0.95) | |
| Frames | No Frames |
1: /* MultiButtonUI.java -- 2: Copyright (C) 2005 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: package javax.swing.plaf.multi; 39: 40: import java.awt.Dimension; 41: import java.awt.Graphics; 42: import java.util.Iterator; 43: import java.util.Vector; 44: 45: import javax.accessibility.Accessible; 46: import javax.swing.JComponent; 47: import javax.swing.LookAndFeel; 48: import javax.swing.UIManager; 49: import javax.swing.plaf.ButtonUI; 50: import javax.swing.plaf.ComponentUI; 51: 52: /** 53: * A UI delegate that that coordinates multiple {@link ButtonUI} instances, one 54: * from the primary look and feel, and one or more from the auxiliary look and 55: * feel(s). 56: * 57: * @see UIManager#addAuxiliaryLookAndFeel(LookAndFeel) 58: */ 59: public class MultiButtonUI extends ButtonUI 60: { 61: 62: /** A list of references to the actual component UIs. */ 63: protected Vector uis; 64: 65: /** 66: * Creates a new <code>MultiButtonUI</code> instance. 67: * 68: * @see #createUI(JComponent) 69: */ 70: public MultiButtonUI() 71: { 72: uis = new Vector(); 73: } 74: 75: /** 76: * Creates a delegate object for the specified component. If any auxiliary 77: * look and feels support this component, a <code>MultiButtonUI</code> is 78: * returned, otherwise the UI from the default look and feel is returned. 79: * 80: * @param target the component. 81: * 82: * @see MultiLookAndFeel#createUIs(ComponentUI, Vector, JComponent) 83: */ 84: public static ComponentUI createUI(JComponent target) 85: { 86: MultiButtonUI mui = new MultiButtonUI(); 87: return MultiLookAndFeel.createUIs(mui, mui.uis, target); 88: } 89: 90: /** 91: * Calls the {@link ComponentUI#installUI(JComponent)} method for all 92: * the UI delegates managed by this <code>MultiButtonUI</code>. 93: * 94: * @param c the component. 95: */ 96: public void installUI(JComponent c) 97: { 98: Iterator iterator = uis.iterator(); 99: while (iterator.hasNext()) 100: { 101: ComponentUI ui = (ComponentUI) iterator.next(); 102: ui.installUI(c); 103: } 104: } 105: 106: /** 107: * Calls the {@link ComponentUI#uninstallUI(JComponent)} method for all 108: * the UI delegates managed by this <code>MultiButtonUI</code>. 109: * 110: * @param c the component. 111: */ 112: public void uninstallUI(JComponent c) 113: { 114: Iterator iterator = uis.iterator(); 115: while (iterator.hasNext()) 116: { 117: ComponentUI ui = (ComponentUI) iterator.next(); 118: ui.uninstallUI(c); 119: } 120: } 121: 122: /** 123: * Returns an array containing the UI delegates managed by this 124: * <code>MultiButtonUI</code>. The first item in the array is always 125: * the UI delegate from the installed default look and feel. 126: * 127: * @return An array of UI delegates. 128: */ 129: public ComponentUI[] getUIs() 130: { 131: return MultiLookAndFeel.uisToArray(uis); 132: } 133: 134: /** 135: * Calls the {@link ComponentUI#contains(JComponent, int, int)} method for all 136: * the UI delegates managed by this <code>MultiButtonUI</code>, 137: * returning the result for the UI delegate from the primary look and 138: * feel. 139: * 140: * @param c the component. 141: * @param x the x-coordinate. 142: * @param y the y-coordinate. 143: * 144: * @return <code>true</code> if the specified (x, y) coordinate falls within 145: * the bounds of the component as rendered by the UI delegate in the 146: * primary look and feel, and <code>false</code> otherwise. 147: */ 148: public boolean contains(JComponent c, int x, int y) 149: { 150: boolean result = false; 151: Iterator iterator = uis.iterator(); 152: // first UI delegate provides the return value 153: if (iterator.hasNext()) 154: { 155: ComponentUI ui = (ComponentUI) iterator.next(); 156: result = ui.contains(c, x, y); 157: } 158: // return values from auxiliary UI delegates are ignored 159: while (iterator.hasNext()) 160: { 161: ComponentUI ui = (ComponentUI) iterator.next(); 162: /* boolean ignored = */ ui.contains(c, x, y); 163: } 164: return result; 165: } 166: 167: /** 168: * Calls the {@link ComponentUI#update(Graphics, JComponent)} method for all 169: * the UI delegates managed by this <code>MultiButtonUI</code>. 170: * 171: * @param g the graphics device. 172: * @param c the component. 173: */ 174: public void update(Graphics g, JComponent c) 175: { 176: Iterator iterator = uis.iterator(); 177: while (iterator.hasNext()) 178: { 179: ComponentUI ui = (ComponentUI) iterator.next(); 180: ui.update(g, c); 181: } 182: } 183: 184: /** 185: * Calls the <code>paint(Graphics, JComponent)</code> method for all the UI 186: * delegates managed by this <code>MultiButtonUI</code>. 187: * 188: * @param g the graphics device. 189: * @param c the component. 190: */ 191: public void paint(Graphics g, JComponent c) 192: { 193: Iterator iterator = uis.iterator(); 194: while (iterator.hasNext()) 195: { 196: ComponentUI ui = (ComponentUI) iterator.next(); 197: ui.paint(g, c); 198: } 199: } 200: 201: /** 202: * Calls the {@link ComponentUI#getPreferredSize(JComponent)} method for all 203: * the UI delegates managed by this <code>MultiButtonUI</code>, 204: * returning the preferred size for the UI delegate from the primary look and 205: * feel. 206: * 207: * @param c the component. 208: * 209: * @return The preferred size returned by the UI delegate from the primary 210: * look and feel. 211: */ 212: public Dimension getPreferredSize(JComponent c) 213: { 214: Dimension result = null; 215: Iterator iterator = uis.iterator(); 216: // first UI delegate provides the return value 217: if (iterator.hasNext()) 218: { 219: ComponentUI ui = (ComponentUI) iterator.next(); 220: result = ui.getPreferredSize(c); 221: } 222: // return values from auxiliary UI delegates are ignored 223: while (iterator.hasNext()) 224: { 225: ComponentUI ui = (ComponentUI) iterator.next(); 226: /* Dimension ignored = */ ui.getPreferredSize(c); 227: } 228: return result; 229: } 230: 231: /** 232: * Calls the {@link ComponentUI#getMinimumSize(JComponent)} method for all 233: * the UI delegates managed by this <code>MultiButtonUI</code>, 234: * returning the minimum size for the UI delegate from the primary look and 235: * feel. 236: * 237: * @param c the component. 238: * 239: * @return The minimum size returned by the UI delegate from the primary 240: * look and feel. 241: */ 242: public Dimension getMinimumSize(JComponent c) 243: { 244: Dimension result = null; 245: Iterator iterator = uis.iterator(); 246: // first UI delegate provides the return value 247: if (iterator.hasNext()) 248: { 249: ComponentUI ui = (ComponentUI) iterator.next(); 250: result = ui.getMinimumSize(c); 251: } 252: // return values from auxiliary UI delegates are ignored 253: while (iterator.hasNext()) 254: { 255: ComponentUI ui = (ComponentUI) iterator.next(); 256: /* Dimension ignored = */ ui.getMinimumSize(c); 257: } 258: return result; 259: } 260: 261: /** 262: * Calls the {@link ComponentUI#getMaximumSize(JComponent)} method for all 263: * the UI delegates managed by this <code>MultiButtonUI</code>, 264: * returning the maximum size for the UI delegate from the primary look and 265: * feel. 266: * 267: * @param c the component. 268: * 269: * @return The maximum size returned by the UI delegate from the primary 270: * look and feel. 271: */ 272: public Dimension getMaximumSize(JComponent c) 273: { 274: Dimension result = null; 275: Iterator iterator = uis.iterator(); 276: // first UI delegate provides the return value 277: if (iterator.hasNext()) 278: { 279: ComponentUI ui = (ComponentUI) iterator.next(); 280: result = ui.getMaximumSize(c); 281: } 282: // return values from auxiliary UI delegates are ignored 283: while (iterator.hasNext()) 284: { 285: ComponentUI ui = (ComponentUI) iterator.next(); 286: /* Dimension ignored = */ ui.getMaximumSize(c); 287: } 288: return result; 289: } 290: 291: /** 292: * Calls the {@link ComponentUI#getAccessibleChildrenCount(JComponent)} method 293: * for all the UI delegates managed by this <code>MultiButtonUI</code>, 294: * returning the count for the UI delegate from the primary look and 295: * feel. 296: * 297: * @param c the component. 298: * 299: * @return The count returned by the UI delegate from the primary 300: * look and feel. 301: */ 302: public int getAccessibleChildrenCount(JComponent c) 303: { 304: int result = 0; 305: Iterator iterator = uis.iterator(); 306: // first UI delegate provides the return value 307: if (iterator.hasNext()) 308: { 309: ComponentUI ui = (ComponentUI) iterator.next(); 310: result = ui.getAccessibleChildrenCount(c); 311: } 312: // return values from auxiliary UI delegates are ignored 313: while (iterator.hasNext()) 314: { 315: ComponentUI ui = (ComponentUI) iterator.next(); 316: /* int ignored = */ ui.getAccessibleChildrenCount(c); 317: } 318: return result; 319: } 320: 321: /** 322: * Calls the {@link ComponentUI#getAccessibleChild(JComponent, int)} method 323: * for all the UI delegates managed by this <code>MultiButtonUI</code>, 324: * returning the child for the UI delegate from the primary look and 325: * feel. 326: * 327: * @param c the component 328: * @param i the child index. 329: * 330: * @return The child returned by the UI delegate from the primary 331: * look and feel. 332: */ 333: public Accessible getAccessibleChild(JComponent c, int i) 334: { 335: Accessible result = null; 336: Iterator iterator = uis.iterator(); 337: // first UI delegate provides the return value 338: if (iterator.hasNext()) 339: { 340: ComponentUI ui = (ComponentUI) iterator.next(); 341: result = ui.getAccessibleChild(c, i); 342: } 343: // return values from auxiliary UI delegates are ignored 344: while (iterator.hasNext()) 345: { 346: ComponentUI ui = (ComponentUI) iterator.next(); 347: /* Accessible ignored = */ ui.getAccessibleChild(c, i); 348: } 349: return result; 350: } 351:
| GNU Classpath (0.95) |