Source for javax.swing.plaf.multi.MultiOptionPaneUI

   1: /* MultiOptionPaneUI.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.JOptionPane;
  48: import javax.swing.LookAndFeel;
  49: import javax.swing.UIManager;
  50: import javax.swing.plaf.ComponentUI;
  51: import javax.swing.plaf.OptionPaneUI;
  52: 
  53: /**
  54:  * A UI delegate that that coordinates multiple {@link OptionPaneUI} 
  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 MultiOptionPaneUI extends OptionPaneUI 
  61: {
  62: 
  63:   /** A list of references to the actual component UIs. */
  64:   protected Vector uis;
  65:     
  66:   /**
  67:    * Creates a new <code>MultiOptionPaneUI</code> instance.
  68:    * 
  69:    * @see #createUI(JComponent)
  70:    */
  71:   public MultiOptionPaneUI() 
  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>MultiOptionPaneUI</code> is
  79:    * 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:     MultiOptionPaneUI mui = new MultiOptionPaneUI();
  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>MultiOptionPaneUI</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>MultiOptionPaneUI</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>MultiOptionPaneUI</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>MultiOptionPaneUI</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>MultiOptionPaneUI</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>MultiOptionPaneUI</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>MultiOptionPaneUI</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>MultiOptionPaneUI</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>MultiOptionPaneUI</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>MultiOptionPaneUI</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>MultiOptionPaneUI</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 OptionPaneUI#selectInitialValue(JOptionPane)} method for
 355:    * all the UI delegates managed by this <code>MultiOptionPaneUI</code>.
 356:    * 
 357:    * @param pane  the option pane.
 358:    */
 359:   public void selectInitialValue(JOptionPane pane) 
 360:   {
 361:     Iterator iterator = uis.iterator();
 362:     while (iterator.hasNext())
 363:     {
 364:       OptionPaneUI ui = (OptionPaneUI) iterator.next();
 365:       ui.selectInitialValue(pane);
 366:     }
 367:   }
 368: 
 369:   /**
 370:    * Calls the {@link OptionPaneUI#containsCustomComponents(JOptionPane)} 
 371:    * method for all the UI delegates managed by this 
 372:    * <code>MultiOptionPaneUI</code>, returning the result for the UI delegate 
 373:    * from the primary look and feel. 
 374:    * 
 375:    * @param pane  the option pane.
 376:    * 
 377:    * @return The result for the UI delegate from the primary look and feel. 
 378:    */
 379:   public boolean containsCustomComponents(JOptionPane pane) 
 380:   {
 381:     boolean result = false;
 382:     Iterator iterator = uis.iterator();
 383:     // first UI delegate provides the return value
 384:     if (iterator.hasNext()) 
 385:       {
 386:         OptionPaneUI ui = (OptionPaneUI) iterator.next();
 387:         result = ui.containsCustomComponents(pane);
 388:       }
 389:     // return values from auxiliary UI delegates are ignored
 390:     while (iterator.hasNext())
 391:       {
 392:         OptionPaneUI ui = (OptionPaneUI) iterator.next();
 393:         /* boolean ignored = */ ui.containsCustomComponents(pane);
 394:       }
 395:     return result;
 396:   }
 397: 
 398: }