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