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