001 /* JDialog.java --
002 Copyright (C) 2002, 2004 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
039 package javax.swing;
040
041 import java.awt.AWTEvent;
042 import java.awt.Component;
043 import java.awt.Container;
044 import java.awt.Dialog;
045 import java.awt.Dimension;
046 import java.awt.Frame;
047 import java.awt.Graphics;
048 import java.awt.GraphicsConfiguration;
049 import java.awt.IllegalComponentStateException;
050 import java.awt.LayoutManager;
051 import java.awt.event.WindowEvent;
052
053 import javax.accessibility.Accessible;
054 import javax.accessibility.AccessibleContext;
055
056 /**
057 * A dialog window. This is an extension of {@link java.awt.Dialog} that
058 * provides support for the Swing architecture. Most importantly it contains a
059 * {@link JRootPane} as it's only top-level child, that manages the content
060 * pane, the menu and a glass pane.
061 *
062 * Also, unlike <code>java.awt.Dialog</code>s, JDialogs support the
063 * Swing Pluggable Look & Feel architecture.
064 *
065 * @author Ronald Veldema (rveldema@cs.vu.nl)
066 */
067 public class JDialog extends Dialog implements Accessible, WindowConstants,
068 RootPaneContainer
069 {
070 /**
071 * Provides accessibility support for <code>JDialog</code>s.
072 */
073 protected class AccessibleJDialog extends Dialog.AccessibleAWTDialog
074 {
075 /**
076 * Creates a new instance of <code>AccessibleJDialog</code>.
077 */
078 protected AccessibleJDialog()
079 {
080 super();
081 // Nothing to do here.
082 }
083 }
084
085 private static final long serialVersionUID = -864070866424508218L;
086
087 /** DOCUMENT ME! */
088 protected AccessibleContext accessibleContext;
089
090 /** The single RootPane in the Dialog. */
091 protected JRootPane rootPane;
092
093 /**
094 * Whether checking is enabled on the RootPane.
095 *
096 * @specnote Should be false to comply with J2SE 5.0
097 */
098 protected boolean rootPaneCheckingEnabled = false;
099
100 /** The default action taken when closed. */
101 private int closeAction = HIDE_ON_CLOSE;
102
103 /** Whether JDialogs are decorated by the Look and Feel. */
104 private static boolean decorated;
105
106 /* Creates a new non-modal JDialog with no title
107 * using a shared Frame as the owner.
108 */
109 public JDialog()
110 {
111 this((Frame) SwingUtilities.getOwnerFrame(null), "", false, null);
112 }
113
114 /**
115 * Creates a new non-modal JDialog with no title
116 * using the given owner.
117 *
118 * @param owner The owner of the JDialog.
119 */
120 public JDialog(Dialog owner)
121 {
122 this(owner, "", false, null);
123 }
124
125 /**
126 * Creates a new JDialog with no title using the
127 * given modal setting and owner.
128 *
129 * @param owner The owner of the JDialog.
130 * @param modal Whether the JDialog is modal.
131 */
132 public JDialog(Dialog owner, boolean modal)
133 {
134 this(owner, "", modal, null);
135 }
136
137 /**
138 * Creates a new non-modal JDialog using the
139 * given title and owner.
140 *
141 * @param owner The owner of the JDialog.
142 * @param title The title of the JDialog.
143 */
144 public JDialog(Dialog owner, String title)
145 {
146 this(owner, title, false, null);
147 }
148
149 /**
150 * Creates a new JDialog using the given modal
151 * settings, title, and owner.
152 *
153 * @param owner The owner of the JDialog.
154 * @param title The title of the JDialog.
155 * @param modal Whether the JDialog is modal.
156 */
157 public JDialog(Dialog owner, String title, boolean modal)
158 {
159 this(owner, title, modal, null);
160 }
161
162 /**
163 * Creates a new JDialog using the given modal
164 * settings, title, owner and graphics configuration.
165 *
166 * @param owner The owner of the JDialog.
167 * @param title The title of the JDialog.
168 * @param modal Whether the JDialog is modal.
169 * @param gc The Graphics Configuration to use.
170 */
171 public JDialog(Dialog owner, String title, boolean modal,
172 GraphicsConfiguration gc)
173 {
174 super(owner, title, modal, gc);
175 dialogInit();
176 }
177
178 /**
179 * Creates a new non-modal JDialog with no title
180 * using the given owner.
181 *
182 * @param owner The owner of the JDialog.
183 */
184 public JDialog(Frame owner)
185 {
186 this(owner, "", false, null);
187 }
188
189 /**
190 * Creates a new JDialog with no title using the
191 * given modal setting and owner.
192 *
193 * @param owner The owner of the JDialog.
194 * @param modal Whether the JDialog is modal.
195 */
196 public JDialog(Frame owner, boolean modal)
197 {
198 this(owner, "", modal, null);
199 }
200
201 /**
202 * Creates a new non-modal JDialog using the
203 * given title and owner.
204 *
205 * @param owner The owner of the JDialog.
206 * @param title The title of the JDialog.
207 */
208 public JDialog(Frame owner, String title)
209 {
210 this(owner, title, false, null);
211 }
212
213 /**
214 * Creates a new JDialog using the given modal
215 * settings, title, and owner.
216 *
217 * @param owner The owner of the JDialog.
218 * @param title The title of the JDialog.
219 * @param modal Whether the JDialog is modal.
220 */
221 public JDialog(Frame owner, String title, boolean modal)
222 {
223 this(owner, title, modal, null);
224 }
225
226 /**
227 * Creates a new JDialog using the given modal
228 * settings, title, owner and graphics configuration.
229 *
230 * @param owner The owner of the JDialog.
231 * @param title The title of the JDialog.
232 * @param modal Whether the JDialog is modal.
233 * @param gc The Graphics Configuration to use.
234 */
235 public JDialog(Frame owner, String title, boolean modal,
236 GraphicsConfiguration gc)
237 {
238 super((Frame) SwingUtilities.getOwnerFrame(owner), title, modal, gc);
239 dialogInit();
240 }
241
242 /**
243 * This method is called to initialize the
244 * JDialog. It sets the layout used, the locale,
245 * and creates the RootPane.
246 */
247 protected void dialogInit()
248 {
249 // We need to explicitly enable events here so that our processKeyEvent()
250 // and processWindowEvent() gets called.
251 enableEvents(AWTEvent.WINDOW_EVENT_MASK);
252
253 // FIXME: Do a check on GraphicsEnvironment.isHeadless()
254 setLocale(JComponent.getDefaultLocale());
255 getRootPane(); // Will do set/create.
256 invalidate();
257 // Now that initStageDone is true, adds and layouts apply to contentPane,
258 // not top-level.
259 setRootPaneCheckingEnabled(true);
260 }
261
262 /**
263 * This method returns whether JDialogs will have their
264 * window decorations provided by the Look and Feel.
265 *
266 * @return Whether the window decorations are Look and Feel provided.
267 */
268 public static boolean isDefaultLookAndFeelDecorated()
269 {
270 return decorated;
271 }
272
273 /**
274 * This method sets whether JDialogs will have their
275 * window decorations provided by the Look and Feel.
276 *
277 * @param defaultLookAndFeelDecorated Whether the window
278 * decorations are Look and Feel provided.
279 */
280 public static void setDefaultLookAndFeelDecorated(boolean defaultLookAndFeelDecorated)
281 {
282 decorated = defaultLookAndFeelDecorated;
283 }
284
285 /**
286 * This method returns the preferred size of
287 * the JDialog.
288 *
289 * @return The preferred size.
290 */
291 public Dimension getPreferredSize()
292 {
293 Dimension d = super.getPreferredSize();
294 return d;
295 }
296
297 /**
298 * This method returns the JMenuBar used
299 * in this JDialog.
300 *
301 * @return The JMenuBar in the JDialog.
302 */
303 public JMenuBar getJMenuBar()
304 {
305 return getRootPane().getJMenuBar();
306 }
307
308 /**
309 * This method sets the JMenuBar used
310 * in this JDialog.
311 *
312 * @param menubar The JMenuBar to use.
313 */
314 public void setJMenuBar(JMenuBar menubar)
315 {
316 getRootPane().setJMenuBar(menubar);
317 }
318
319 /**
320 * This method sets the LayoutManager used in the JDialog.
321 * This method will throw an Error if rootPaneChecking is
322 * enabled.
323 *
324 * @param manager The LayoutManager to use.
325 */
326 public void setLayout(LayoutManager manager)
327 {
328 // Check if we're in initialization stage. If so, call super.setLayout
329 // otherwise, valid calls go to the content pane.
330 if (isRootPaneCheckingEnabled())
331 getContentPane().setLayout(manager);
332 else
333 super.setLayout(manager);
334 }
335
336 /**
337 * This method sets the JLayeredPane used in the JDialog.
338 * If the given JLayeredPane is null, then this method
339 * will throw an Error.
340 *
341 * @param layeredPane The JLayeredPane to use.
342 */
343 public void setLayeredPane(JLayeredPane layeredPane)
344 {
345 if (layeredPane == null)
346 throw new IllegalComponentStateException("layeredPane cannot be null.");
347 getRootPane().setLayeredPane(layeredPane);
348 }
349
350 /**
351 * This method returns the JLayeredPane used with this JDialog.
352 *
353 * @return The JLayeredPane used with this JDialog.
354 */
355 public JLayeredPane getLayeredPane()
356 {
357 return getRootPane().getLayeredPane();
358 }
359
360 /**
361 * This method returns the JRootPane used with this JDialog.
362 *
363 * @return The JRootPane used with this JDialog.
364 */
365 public JRootPane getRootPane()
366 {
367 if (rootPane == null)
368 setRootPane(createRootPane());
369 return rootPane;
370 }
371
372 /**
373 * This method sets the JRootPane used with this JDialog.
374 *
375 * @param root The JRootPane to use.
376 */
377 protected void setRootPane(JRootPane root)
378 {
379 if (rootPane != null)
380 remove(rootPane);
381
382 rootPane = root;
383 rootPane.show();
384 add(rootPane);
385 }
386
387 /**
388 * This method creates a new JRootPane.
389 *
390 * @return A new JRootPane.
391 */
392 protected JRootPane createRootPane()
393 {
394 return new JRootPane();
395 }
396
397 /**
398 * This method returns the ContentPane
399 * in the JRootPane.
400 *
401 * @return The ContentPane in the JRootPane.
402 */
403 public Container getContentPane()
404 {
405 return getRootPane().getContentPane();
406 }
407
408 /**
409 * This method sets the ContentPane to use with this
410 * JDialog. If the ContentPane given is null, this method
411 * will throw an exception.
412 *
413 * @param contentPane The ContentPane to use with the JDialog.
414 */
415 public void setContentPane(Container contentPane)
416 {
417 if (contentPane == null)
418 throw new IllegalComponentStateException("contentPane cannot be null.");
419 getRootPane().setContentPane(contentPane);
420 }
421
422 /**
423 * This method returns the GlassPane for this JDialog.
424 *
425 * @return The GlassPane for this JDialog.
426 */
427 public Component getGlassPane()
428 {
429 return getRootPane().getGlassPane();
430 }
431
432 /**
433 * This method sets the GlassPane for this JDialog.
434 *
435 * @param glassPane The GlassPane for this JDialog.
436 */
437 public void setGlassPane(Component glassPane)
438 {
439 getRootPane().setGlassPane(glassPane);
440 }
441
442 /**
443 * This method is called when a component is added to the
444 * the JDialog. Calling this method with rootPaneCheckingEnabled
445 * will cause an Error to be thrown.
446 *
447 * @param comp The component to add.
448 * @param constraints The constraints.
449 * @param index The position of the component.
450 */
451 protected void addImpl(Component comp, Object constraints, int index)
452 {
453 // If we're adding in the initialization stage use super.add.
454 // Otherwise pass the add onto the content pane.
455 if (isRootPaneCheckingEnabled())
456 getContentPane().add(comp, constraints, index);
457 else
458 super.addImpl(comp, constraints, index);
459 }
460
461 /**
462 * This method removes a component from the JDialog.
463 *
464 * @param comp The component to remove.
465 */
466 public void remove(Component comp)
467 {
468 // If we're removing the root pane, use super.remove. Otherwise
469 // pass it on to the content pane instead.
470 if (comp == rootPane)
471 super.remove(rootPane);
472 else
473 getContentPane().remove(comp);
474 }
475
476 /**
477 * This method returns whether rootPane checking is enabled.
478 *
479 * @return Whether rootPane checking is enabled.
480 */
481 protected boolean isRootPaneCheckingEnabled()
482 {
483 return rootPaneCheckingEnabled;
484 }
485
486 /**
487 * This method sets whether rootPane checking is enabled.
488 *
489 * @param enabled Whether rootPane checking is enabled.
490 */
491 protected void setRootPaneCheckingEnabled(boolean enabled)
492 {
493 rootPaneCheckingEnabled = enabled;
494 }
495
496 /**
497 * This method simply calls paint and returns.
498 *
499 * @param g The Graphics object to paint with.
500 */
501 public void update(Graphics g)
502 {
503 paint(g);
504 }
505
506
507 /**
508 * This method handles window events. This allows the JDialog
509 * to honour its default close operation.
510 *
511 * @param e The WindowEvent.
512 */
513 protected void processWindowEvent(WindowEvent e)
514 {
515 super.processWindowEvent(e);
516 if (e.getID() == WindowEvent.WINDOW_CLOSING)
517 {
518 switch (closeAction)
519 {
520 case EXIT_ON_CLOSE:
521 System.exit(0);
522 break;
523 case DISPOSE_ON_CLOSE:
524 dispose();
525 break;
526 case HIDE_ON_CLOSE:
527 setVisible(false);
528 break;
529 case DO_NOTHING_ON_CLOSE:
530 break;
531 }
532 }
533 }
534
535 /**
536 * This method sets the action to take
537 * when the JDialog is closed.
538 *
539 * @param operation The action to take.
540 */
541 public void setDefaultCloseOperation(int operation)
542 {
543 /* Reference implementation allows invalid operations
544 to be specified. If so, getDefaultCloseOperation
545 must return the invalid code, and the behaviour
546 defaults to DO_NOTHING_ON_CLOSE. processWindowEvent
547 above handles this */
548 closeAction = operation;
549 }
550
551 /**
552 * This method returns the action taken when
553 * the JDialog is closed.
554 *
555 * @return The action to take.
556 */
557 public int getDefaultCloseOperation()
558 {
559 return closeAction;
560 }
561
562 /**
563 * This method returns a String describing the JDialog.
564 *
565 * @return A String describing the JDialog.
566 */
567 protected String paramString()
568 {
569 return "JDialog";
570 }
571
572 /**
573 * DOCUMENT ME!
574 *
575 * @return DOCUMENT ME!
576 */
577 public AccessibleContext getAccessibleContext()
578 {
579 if (accessibleContext == null)
580 accessibleContext = new AccessibleJDialog();
581 return accessibleContext;
582 }
583 }