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    */
MultiOptionPaneUI()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    */
createUI(JComponent target)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    */
installUI(JComponent c)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    */
uninstallUI(JComponent c)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    */
getUIs()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    */
contains(JComponent c, int x, int y)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    */
update(Graphics g, JComponent c)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    */
paint(Graphics g, JComponent c)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    */
getPreferredSize(JComponent c)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    */
getMinimumSize(JComponent c)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    */
getMaximumSize(JComponent c)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    */
getAccessibleChildrenCount(JComponent c)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    */
getAccessibleChild(JComponent c, int i)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    */
selectInitialValue(JOptionPane pane)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    */
containsCustomComponents(JOptionPane pane)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 }
399