Source for javax.swing.plaf.multi.MultiComboBoxUI

   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: }