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