001    /* MultiOptionPaneUI.java --
002       Copyright (C) 2005 Free Software Foundation, Inc.
003    
004    This file is part of GNU Classpath.
005    
006    GNU Classpath is free software; you can redistribute it and/or modify
007    it under the terms of the GNU General Public License as published by
008    the Free Software Foundation; either version 2, or (at your option)
009    any later version.
010    
011    GNU Classpath is distributed in the hope that it will be useful, but
012    WITHOUT ANY WARRANTY; without even the implied warranty of
013    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
014    General Public License for more details.
015    
016    You should have received a copy of the GNU General Public License
017    along with GNU Classpath; see the file COPYING.  If not, write to the
018    Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
019    02110-1301 USA.
020    
021    Linking this library statically or dynamically with other modules is
022    making a combined work based on this library.  Thus, the terms and
023    conditions of the GNU General Public License cover the whole
024    combination.
025    
026    As a special exception, the copyright holders of this library give you
027    permission to link this library with independent modules to produce an
028    executable, regardless of the license terms of these independent
029    modules, and to copy and distribute the resulting executable under
030    terms of your choice, provided that you also meet, for each linked
031    independent module, the terms and conditions of the license of that
032    module.  An independent module is a module which is not derived from
033    or based on this library.  If you modify this library, you may extend
034    this exception to your version of the library, but you are not
035    obligated to do so.  If you do not wish to do so, delete this
036    exception statement from your version. */
037    
038    package javax.swing.plaf.multi;
039    
040    import java.awt.Dimension;
041    import java.awt.Graphics;
042    import java.util.Iterator;
043    import java.util.Vector;
044    
045    import javax.accessibility.Accessible;
046    import javax.swing.JComponent;
047    import javax.swing.JOptionPane;
048    import javax.swing.LookAndFeel;
049    import javax.swing.UIManager;
050    import javax.swing.plaf.ComponentUI;
051    import javax.swing.plaf.OptionPaneUI;
052    
053    /**
054     * A UI delegate that that coordinates multiple {@link OptionPaneUI} 
055     * instances, one from the primary look and feel, and one or more from the 
056     * auxiliary look and feel(s).
057     * 
058     * @see UIManager#addAuxiliaryLookAndFeel(LookAndFeel)
059     */
060    public class MultiOptionPaneUI extends OptionPaneUI 
061    {
062    
063      /** A list of references to the actual component UIs. */
064      protected Vector uis;
065        
066      /**
067       * Creates a new <code>MultiOptionPaneUI</code> instance.
068       * 
069       * @see #createUI(JComponent)
070       */
071      public MultiOptionPaneUI() 
072      {
073        uis = new Vector();
074      }
075      
076      /**
077       * Creates a delegate object for the specified component.  If any auxiliary 
078       * look and feels support this component, a <code>MultiOptionPaneUI</code> is
079       * returned, otherwise the UI from the default look and feel is returned.
080       * 
081       * @param target  the component.
082       * 
083       * @see MultiLookAndFeel#createUIs(ComponentUI, Vector, JComponent)
084       */
085      public static ComponentUI createUI(JComponent target)
086      {
087        MultiOptionPaneUI mui = new MultiOptionPaneUI();
088        return MultiLookAndFeel.createUIs(mui, mui.uis, target);
089      }
090      
091      /**
092       * Calls the {@link ComponentUI#installUI(JComponent)} method for all 
093       * the UI delegates managed by this <code>MultiOptionPaneUI</code>.
094       * 
095       * @param c  the component.
096       */
097      public void installUI(JComponent c)
098      {
099        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    }