old-autovect-branch/libjava/classpath/javax/swing/plaf/multi/MultiInternalFrameUI.java

   1 /* MultiInternalFrameUI.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.ComponentUI;
  50 import javax.swing.plaf.InternalFrameUI;
  51
  52 /**
  53  * A UI delegate that that coordinates multiple {@link InternalFrameUI}
  54  * instances, one from the primary look and feel, and one or more from the
  55  * auxiliary look and feel(s).
  56  *
  57  * @see UIManager#addAuxiliaryLookAndFeel(LookAndFeel)
  58  */
  59 public class MultiInternalFrameUI extends InternalFrameUI
  60 {
  61
  62   /** A list of references to the actual component UIs. */
  63   protected Vector uis;
  64
  65   /**
  66    * Creates a new <code>MultiInternalFrameUI</code> instance.
  67    *
  68    * @see #createUI(JComponent)
  69    */
  70   public MultiInternalFrameUI()
  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>MultiInternalFrameUI</code>
  78    * is 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     MultiInternalFrameUI mui = new MultiInternalFrameUI();
  87     return MultiLookAndFeel.createUIs(mui, mui.uis, target);
  88   }
  89
  90
  91   /**
  92    * Calls the {@link ComponentUI#installUI(JComponent)} method for all
  93    * the UI delegates managed by this <code>MultiInternalFrameUI</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>MultiInternalFrameUI</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>MultiInternalFrameUI</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>MultiInternalFrameUI</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>MultiInternalFrameUI</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>MultiInternalFrameUI</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>MultiInternalFrameUI</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>MultiInternalFrameUI</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>MultiInternalFrameUI</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>MultiInternalFrameUI</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>MultiInternalFrameUI</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 }