libjava/classpath/javax/swing/JFrame.java

   1 /* JFrame.java --
   2    Copyright (C) 2002, 2004, 2005, 2006,  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 gnu.java.lang.CPStringBuilder;
  42
  43 import java.awt.AWTEvent;
  44 import java.awt.BorderLayout;
  45 import java.awt.Component;
  46 import java.awt.Container;
  47 import java.awt.Dimension;
  48 import java.awt.Frame;
  49 import java.awt.Graphics;
  50 import java.awt.GraphicsConfiguration;
  51 import java.awt.LayoutManager;
  52 import java.awt.event.KeyEvent;
  53 import java.awt.event.WindowEvent;
  54
  55 import javax.accessibility.Accessible;
  56 import javax.accessibility.AccessibleContext;
  57
  58 /**
  59  * A window that supports window decorations (titlebar and borders).
  60  * This is an extension of {@link java.awt.Frame} that provides support
  61  * for the Swing architecture. Most importantly it contains a {@link JRootPane}
  62  * as it's only top-level child, that manages the content pane, the menu and
  63  * a glass pane.
  64  *
  65  * Also, unlike <code>java.awt.Frame</code>s, JFrames support the
  66  * Swing Pluggable Look &amp; Feel architecture.
  67  *
  68  * @author Ronald Veldema (rveldema@cs.vu.nl)
  69  */
  70 public class JFrame extends Frame
  71   implements WindowConstants, RootPaneContainer, Accessible
  72 {
  73   /**
  74    * Provides accessibility support for <code>JFrame</code>s.
  75    */
  76   protected class AccessibleJFrame extends Frame.AccessibleAWTFrame
  77   {
  78     /**
  79      * Creates a new instance of <code>AccessibleJFrame</code>.
  80      */
  81     protected AccessibleJFrame()
  82     {
  83       super();
  84       // Nothing to do here.
  85     }
  86   }
  87
  88   /**
  89    * A flag for {@link #setDefaultCloseOperation(int)}, indicating that the
  90    * application should be exited, when this <code>JFrame</code> is closed.
  91    * Note that in version 1.4, the equivalent constant has been added to
  92    * {@link WindowConstants}.
  93    *
  94    * @since 1.3
  95    */
  96   public static final int EXIT_ON_CLOSE = 3;
  97
  98   private static final long serialVersionUID = -3362141868504252139L;
  99   private static boolean defaultLookAndFeelDecorated;
 100   private int closeAction = HIDE_ON_CLOSE;
 101   protected AccessibleContext accessibleContext;
 102   protected JRootPane rootPane;
 103
 104   /**
 105    * @specnote rootPaneCheckingEnabled is false to comply with J2SE 5.0
 106    */
 107   protected boolean rootPaneCheckingEnabled = false;
 108
 109   /**
 110    * Creates a new frame with an empty string for the title.
 111    */
 112   public JFrame()
 113   {
 114     super("");
 115     frameInit();
 116   }
 117
 118   /**
 119    * Creates a new <code>JFrame</code> with the specified title.
 120    *
 121    * @param title  the frame title (<code>null</code> permitted).
 122    */
 123   public JFrame(String title)
 124   {
 125     super(title);
 126     frameInit();
 127   }
 128
 129   /**
 130    * Creates a new JFrame in the specified {@link GraphicsConfiguration}
 131    * and with an empty title.
 132    *
 133    * @param gc the <code>GraphicsConfiguration</code> that is used for
 134    *     the new <code>JFrame</code>
 135    *
 136    * @see Frame#Frame(GraphicsConfiguration)
 137    */
 138   public JFrame(GraphicsConfiguration gc)
 139   {
 140     super(gc);
 141     frameInit();
 142   }
 143
 144   /**
 145    * Creates a new JFrame in the specified {@link GraphicsConfiguration}
 146    * and with the specified title.
 147    *
 148    * @param title the title for the new <code>JFrame</code>
 149    * @param gc the <code>GraphicsConfiguration</code> that is used for
 150    *     the new <code>JFrame</code>
 151    *
 152    * @see Frame#Frame(String, GraphicsConfiguration)
 153    */
 154   public JFrame(String title, GraphicsConfiguration gc)
 155   {
 156     super(title, gc);
 157     frameInit();
 158   }
 159
 160   protected void frameInit()
 161   {
 162     // We need to explicitly enable events here so that our processKeyEvent()
 163     // and processWindowEvent() gets called.
 164     enableEvents(AWTEvent.WINDOW_EVENT_MASK | AWTEvent.KEY_EVENT_MASK);
 165
 166     super.setLayout(new BorderLayout());
 167     setBackground(UIManager.getDefaults().getColor("control"));
 168     enableEvents(AWTEvent.WINDOW_EVENT_MASK);
 169     getRootPane(); // will do set/create
 170
 171     // Setup the defaultLookAndFeelDecoration if requested.
 172     if (isDefaultLookAndFeelDecorated()
 173         && UIManager.getLookAndFeel().getSupportsWindowDecorations())
 174       {
 175         setUndecorated(true);
 176         getRootPane().setWindowDecorationStyle(JRootPane.FRAME);
 177       }
 178
 179     // We're now done the init stage.
 180     setRootPaneCheckingEnabled(true);
 181   }
 182
 183   public Dimension getPreferredSize()
 184   {
 185     return super.getPreferredSize();
 186   }
 187
 188   public JMenuBar getJMenuBar()
 189   {
 190     return getRootPane().getJMenuBar();
 191   }
 192
 193   public void setJMenuBar(JMenuBar menubar)
 194   {
 195     getRootPane().setJMenuBar(menubar);
 196   }
 197
 198   public void setLayout(LayoutManager manager)
 199   {
 200     // Check if we're in initialization stage.  If so, call super.setLayout
 201     // otherwise, valid calls go to the content pane.
 202     if (isRootPaneCheckingEnabled())
 203       getContentPane().setLayout(manager);
 204     else
 205       super.setLayout(manager);
 206   }
 207
 208   public void setLayeredPane(JLayeredPane layeredPane)
 209   {
 210     getRootPane().setLayeredPane(layeredPane);
 211   }
 212
 213   public JLayeredPane getLayeredPane()
 214   {
 215     return getRootPane().getLayeredPane();
 216   }
 217
 218   public JRootPane getRootPane()
 219   {
 220     if (rootPane == null)
 221       setRootPane(createRootPane());
 222     return rootPane;
 223   }
 224
 225   protected void setRootPane(JRootPane root)
 226   {
 227     if (rootPane != null)
 228       remove(rootPane);
 229
 230     rootPane = root;
 231     add(rootPane, BorderLayout.CENTER);
 232   }
 233
 234   protected JRootPane createRootPane()
 235   {
 236     return new JRootPane();
 237   }
 238
 239   public Container getContentPane()
 240   {
 241     return getRootPane().getContentPane();
 242   }
 243
 244   public void setContentPane(Container contentPane)
 245   {
 246     getRootPane().setContentPane(contentPane);
 247   }
 248
 249   public Component getGlassPane()
 250   {
 251     return getRootPane().getGlassPane();
 252   }
 253
 254   public void setGlassPane(Component glassPane)
 255   {
 256     getRootPane().setGlassPane(glassPane);
 257   }
 258
 259   protected void addImpl(Component comp, Object constraints, int index)
 260   {
 261     // If we're adding in the initialization stage use super.add.
 262     // Otherwise pass the add onto the content pane.
 263     if (isRootPaneCheckingEnabled() && comp != rootPane)
 264       getContentPane().add(comp,constraints,index);
 265     else
 266       super.addImpl(comp, constraints, index);
 267   }
 268
 269   public void remove(Component comp)
 270   {
 271     // If we're removing the root pane, use super.remove. Otherwise
 272     // pass it on to the content pane instead.
 273     if (comp==rootPane)
 274       super.remove(rootPane);
 275     else
 276       getContentPane().remove(comp);
 277   }
 278
 279   protected boolean isRootPaneCheckingEnabled()
 280   {
 281     return rootPaneCheckingEnabled;
 282   }
 283
 284   protected void setRootPaneCheckingEnabled(boolean enabled)
 285   {
 286     rootPaneCheckingEnabled = enabled;
 287   }
 288
 289   public void update(Graphics g)
 290   {
 291     paint(g);
 292   }
 293
 294   protected void processKeyEvent(KeyEvent e)
 295   {
 296     super.processKeyEvent(e);
 297   }
 298
 299   public static void setDefaultLookAndFeelDecorated(boolean decorated)
 300   {
 301     defaultLookAndFeelDecorated = decorated;
 302   }
 303
 304   public static boolean isDefaultLookAndFeelDecorated()
 305   {
 306     return defaultLookAndFeelDecorated;
 307   }
 308
 309   /**
 310    * Returns the object that provides accessibility features for this
 311    * <code>JFrame</code>.
 312    *
 313    * @return The accessible context (an instance of {@link AccessibleJFrame}).
 314    */
 315   public AccessibleContext getAccessibleContext()
 316   {
 317     if (accessibleContext == null)
 318       accessibleContext = new AccessibleJFrame();
 319     return accessibleContext;
 320   }
 321
 322   /**
 323    * Returns a code for the default operation when the frame is closed.  The
 324    * default value is {@link WindowConstants#HIDE_ON_CLOSE}.
 325    *
 326    * @return One of: {@link WindowConstants#DO_NOTHING_ON_CLOSE},
 327    *     {@link WindowConstants#HIDE_ON_CLOSE},
 328    *     {@link WindowConstants#DISPOSE_ON_CLOSE}, {@link #EXIT_ON_CLOSE}.
 329    *
 330    * @see #setDefaultCloseOperation(int)
 331    */
 332   public int getDefaultCloseOperation()
 333   {
 334     return closeAction;
 335   }
 336
 337   /**
 338    * Returns a string describing the attributes for the <code>JFrame</code>,
 339    * for use in debugging.  The return value is guaranteed to be
 340    * non-<code>null</code>, but the format may vary between implementations.
 341    *
 342    * @return A string describing the attributes of the <code>JFrame</code>.
 343    */
 344   protected String paramString()
 345   {
 346     CPStringBuilder sb = new CPStringBuilder(super.paramString());
 347     sb.append(",defaultCloseOperation=");
 348     sb.append(SwingUtilities.convertWindowConstantToString(
 349         getDefaultCloseOperation()));
 350     sb.append(",rootPane=");
 351     if (rootPane != null)
 352       sb.append(rootPane);
 353     sb.append(",rootPaneCheckingEnabled=").append(rootPaneCheckingEnabled);
 354     return sb.toString();
 355   }
 356
 357   protected void processWindowEvent(WindowEvent e)
 358   {
 359     super.processWindowEvent(e);
 360     if (e.getID() == WindowEvent.WINDOW_CLOSING)
 361       {
 362         switch (closeAction)
 363           {
 364           case EXIT_ON_CLOSE:
 365             System.exit(0);
 366             break;
 367           case DISPOSE_ON_CLOSE:
 368             dispose();
 369             break;
 370           case HIDE_ON_CLOSE:
 371             setVisible(false);
 372             break;
 373           case DO_NOTHING_ON_CLOSE:
 374             break;
 375           }
 376       }
 377   }
 378
 379   /**
 380    * Sets the default operation that is performed when this frame is closed.
 381    * The default is <code>HIDE_ON_CLOSE</code>.  When
 382    * <code>EXIT_ON_CLOSE</code> is specified this method calls
 383    * <code>SecurityManager.checkExit(0)</code> which might throw a
 384    * <code>SecurityException</code>.
 385    *
 386    * @param operation  a code for the operation (one of:
 387    *     {@link WindowConstants#DO_NOTHING_ON_CLOSE},
 388    *     {@link WindowConstants#HIDE_ON_CLOSE},
 389    *     {@link WindowConstants#DISPOSE_ON_CLOSE} and
 390    *     {@link WindowConstants#EXIT_ON_CLOSE}).
 391    *
 392    * @throws IllegalArgumentException if <code>operation</code> is not one of
 393    *     the specified codes.
 394    *
 395    * @see #getDefaultCloseOperation()
 396    */
 397   public void setDefaultCloseOperation(int operation)
 398   {
 399     SecurityManager sm = System.getSecurityManager();
 400     if (sm != null && operation == EXIT_ON_CLOSE)
 401       sm.checkExit(0);
 402
 403     if (operation != EXIT_ON_CLOSE && operation != DISPOSE_ON_CLOSE
 404         && operation != HIDE_ON_CLOSE && operation != DO_NOTHING_ON_CLOSE)
 405       throw new IllegalArgumentException("operation must be EXIT_ON_CLOSE, "
 406           + "HIDE_ON_CLOSE, DISPOSE_ON_CLOSE, or DO_NOTHING_ON_CLOSE");
 407
 408     closeAction = operation;
 409   }
 410 }