home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 November / Chip_1998-11_cd.bin / tema / Cafe / jfc.bin / JWindow.java < prev    next >
Text File  |  1998-02-26  |  21KB  |  711 lines
  1. /*
  2.  * @(#)JWindow.java    1.15 98/02/05
  3.  * 
  4.  * Copyright (c) 1997 Sun Microsystems, Inc. All Rights Reserved.
  5.  * 
  6.  * This software is the confidential and proprietary information of Sun
  7.  * Microsystems, Inc. ("Confidential Information").  You shall not
  8.  * disclose such Confidential Information and shall use it only in
  9.  * accordance with the terms of the license agreement you entered into
  10.  * with Sun.
  11.  * 
  12.  * SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
  13.  * SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
  14.  * IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  15.  * PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
  16.  * SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
  17.  * THIS SOFTWARE OR ITS DERIVATIVES.
  18.  * 
  19.  */
  20. package com.sun.java.swing;
  21.  
  22. import java.awt.*;
  23. import java.awt.event.*;
  24. import java.beans.PropertyChangeListener;
  25. import java.util.Locale;
  26. import java.util.Vector;
  27. import java.io.Serializable;
  28.  
  29. import com.sun.java.accessibility.*;
  30.  
  31. /** The JWindow component contains a JRootPane as it's only child.
  32.   * The contentPane() should be the parent of any children of the JWindow.
  33.   * From the older java.awt.Window object you would normally do something:
  34.   * <PRE>
  35.   *       window.add(child);
  36.   * </PRE>
  37.   * Using JWindow the proper semantic is:
  38.   * <PRE>
  39.   *       window.getContentPane().add(child);
  40.   * </PRE>
  41.   * The same is true of setting LayoutManagers, removing components,
  42.   * listing children, etc. All these methods should normally be sent to
  43.   * the contentPane() instead of the JWindow itself. The contentPane() will
  44.   * always be non-null. Attempting to set it to null will cause the JWindow
  45.   * to throw an exception. The default contentPane() will have a BorderLayout
  46.   * manager set on it. 
  47.   * <p>
  48.   * Please see the JRootPane documentation for a complete description of
  49.   * the contentPane(), glassPane(), and layeredPane() components.
  50.   * <p>
  51.   * Warning: serialized objects of this class will not be compatible with
  52.   * future swing releases.  The current serialization support is appropriate
  53.   * for short term storage or RMI between Swing1.0 applications.  It will
  54.   * not be possible to load serialized Swing1.0 objects with future releases
  55.   * of Swing.  The JDK1.2 release of Swing will be the compatibility
  56.   * baseline for the serialized form of Swing objects.
  57.   *
  58.   * @see JRootPane
  59.   *
  60.   * @beaninfo
  61.   *      attribute: isContainer true
  62.   *      attribute: containerDelegate getContentPane
  63.   *    description: A toplevel window which has no system border or controls.
  64.   *
  65.   * @version 1.15 02/05/98
  66.   * @author David Kloba
  67.   */
  68. public class JWindow extends Window implements Accessible, RootPaneContainer 
  69. {
  70.     /**
  71.      * @see #getRootPane
  72.      * @see #setRootPane
  73.      */
  74.     protected JRootPane rootPane;
  75.  
  76.     /**
  77.      * @see #isRootPaneCheckingEnabled
  78.      * @see #setRootPaneCheckingEnabled
  79.      */
  80.     protected boolean rootPaneCheckingEnabled = false;
  81.  
  82.  
  83.     /**
  84.      * Creates a window with no specified owner.
  85.      */
  86.     public JWindow() {
  87.         this(null);
  88.     }
  89.  
  90.     /**
  91.      * Creates a window with the specified owner frame.
  92.      * @param owner the frame from which the window is displayed
  93.      */
  94.     public JWindow(Frame owner) {
  95.     super(owner == null? SwingUtilities.getSharedOwnerFrame() : owner);    
  96.     windowInit();
  97.     }
  98.  
  99.     /** Called by the constructors to init the JWindow properly. */
  100.     protected void windowInit() {
  101.     setRootPane(createRootPane());
  102.     setRootPaneCheckingEnabled(true);
  103.     }
  104.  
  105.     /** Called by the constructor methods to create the default rootPane. */
  106.     protected JRootPane createRootPane() {
  107.     return new JRootPane();
  108.     }
  109.  
  110.     /**
  111.      * @return true if add and setLayout should be checked
  112.      * @see #addImpl
  113.      * @see #setLayout
  114.      * @see #setRootPaneCheckingEnabled
  115.      */
  116.     protected boolean isRootPaneCheckingEnabled() {
  117.     return rootPaneCheckingEnabled;
  118.     }
  119.  
  120.  
  121.     /**
  122.      * If true then calls to add() and setLayout() will cause an exception
  123.      * to be thrown.  
  124.      *
  125.      * @see #addImpl
  126.      * @see #setLayout
  127.      * @see #isRootPaneCheckingEnabled
  128.      * @beaninfo
  129.      *      hidden: true
  130.      * description: Whether the add and setLayout methods throw exceptions when invoked.
  131.      */
  132.     protected void setRootPaneCheckingEnabled(boolean enabled) {
  133.     rootPaneCheckingEnabled = enabled;
  134.     }
  135.  
  136.  
  137.     /**
  138.      * Create an runtime exception with a message like:
  139.      * <pre>
  140.      * "Do not use JWindow.add() use JWindow.getContentPane().add() instead"
  141.      * </pre>
  142.      */
  143.     private Error createRootPaneException(String op) {
  144.     String type = getClass().getName();
  145.     return new Error(
  146.             "Do not use " + type + "." + op + "() use " 
  147.                           + type + ".getContentPane()." + op + "() instead");
  148.     }
  149.  
  150.  
  151.     /**
  152.      * By default, children may not be added directly to a this component,
  153.      * they must be added to its contentPane instead.  For example:
  154.      * <pre>
  155.      * thisComponent.getContentPane().add(child)
  156.      * </pre>
  157.      * An attempt to add to directly to this component will cause an
  158.      * runtime exception to be thrown.  Subclasses can disable this
  159.      * behavior.
  160.      * 
  161.      * @see #setRootPaneCheckingEnabled
  162.      * @exception Error if called with rootPaneChecking true
  163.      */
  164.     protected void addImpl(Component comp, Object constraints, int index) 
  165.     {
  166.         if(isRootPaneCheckingEnabled()) {
  167.         throw createRootPaneException("add");
  168.     }
  169.     else {
  170.         super.addImpl(comp, constraints, index);
  171.     }
  172.     }
  173.  
  174.  
  175.     /**
  176.      * By default the layout of this component may not be set,
  177.      * the layout of its contentPane should be set instead.  
  178.      * For example:
  179.      * <pre>
  180.      * thisComponent.getContentPane().setLayout(new BorderLayout())
  181.      * </pre>
  182.      * An attempt to set the layout of this component will cause an
  183.      * runtime exception to be thrown.  Subclasses can disable this
  184.      * behavior.
  185.      * 
  186.      * @see #setRootPaneCheckingEnabled
  187.      * @exception Error if called with rootPaneChecking true
  188.      */
  189.     public void setLayout(LayoutManager manager) {
  190.         if(isRootPaneCheckingEnabled()) {
  191.         throw createRootPaneException("setLayout");
  192.     }
  193.     else {
  194.         super.setLayout(manager);
  195.     }
  196.     }
  197.  
  198.  
  199.     /**
  200.      * Returns the rootPane object for this window.
  201.      *
  202.      * @see #setRootPane
  203.      * @see RootPaneContainer#getRootPane
  204.      */
  205.     public JRootPane getRootPane() { 
  206.     return rootPane; 
  207.     }
  208.  
  209.  
  210.     /**
  211.      * Sets the rootPane property.  This method is called by the constructor.
  212.      * @param root the rootPane object for this window
  213.      *
  214.      * @see #getRootPane
  215.      * @see RootPaneContainer#setRootPane
  216.      *
  217.      * @beaninfo
  218.      *   hidden: true
  219.      * description: the RootPane object for this window.
  220.      */
  221.     protected void setRootPane(JRootPane root) {
  222.     if(rootPane != null) {
  223.         remove(rootPane);
  224.     }
  225.     rootPane = root;
  226.     if(rootPane != null) {
  227.         boolean checkingEnabled = isRootPaneCheckingEnabled();
  228.         try {
  229.         setRootPaneCheckingEnabled(false);
  230.         add(rootPane, BorderLayout.CENTER);
  231.         }
  232.         finally {
  233.         setRootPaneCheckingEnabled(checkingEnabled);
  234.         }
  235.         }
  236.     }
  237.  
  238.  
  239.     /**
  240.      * Returns the contentPane object for this window.
  241.      *
  242.      * @see #setContentPane
  243.      * @see RootPaneContainer#getContentPane
  244.      */
  245.     public Container getContentPane() { 
  246.     return getRootPane().getContentPane(); 
  247.     }
  248.  
  249.     /**
  250.      * Sets the contentPane property.  This method is called by the constructor.
  251.      * @param contentPane the contentPane object for this window
  252.      *
  253.      * @see #getContentPane
  254.      * @see RootPaneContainer#setContentPane
  255.      *
  256.      * @beaninfo
  257.      *     hidden: true
  258.      *     description: The client area of the window where child 
  259.      *                  components are normally inserted.
  260.      */
  261.     public void setContentPane(Container contentPane) {
  262.     getRootPane().setContentPane(contentPane);
  263.     }
  264.  
  265.     /**
  266.      * Returns the layeredPane object for this window.
  267.      *
  268.      * @see #setLayeredPane
  269.      * @see RootPaneContainer#getLayeredPane
  270.      */
  271.     public JLayeredPane getLayeredPane() { 
  272.     return getRootPane().getLayeredPane(); 
  273.     }
  274.  
  275.     /**
  276.      * Sets the layeredPane property.  This method is called by the constructor.
  277.      * @param layeredPane the layeredPane object for this window
  278.      *
  279.      * @see #getLayeredPane
  280.      * @see RootPaneContainer#setLayeredPane
  281.      *
  282.      * @beaninfo
  283.      *     hidden: true
  284.      *     description: The pane which holds the various window layers.
  285.      */
  286.     public void setLayeredPane(JLayeredPane layeredPane) {
  287.     getRootPane().setLayeredPane(layeredPane);
  288.     }
  289.  
  290.     /**
  291.      * Returns the glassPane object for this window.
  292.      *
  293.      * @see #setGlassPane
  294.      * @see RootPaneContainer#getGlassPane
  295.      */
  296.     public Component getGlassPane() { 
  297.     return getRootPane().getGlassPane(); 
  298.     }
  299.  
  300.     /**
  301.      * Sets the glassPane property. 
  302.      * This method is called by the constructor.
  303.      * @param glassPane the glassPane object for this window
  304.      *
  305.      * @see #getGlassPane
  306.      * @see RootPaneContainer#setGlassPane
  307.      *
  308.      * @beaninfo
  309.      *     hidden: true
  310.      *     description: A transparent pane used for menu rendering.
  311.      */
  312.     public void setGlassPane(Component glassPane) {
  313.     getRootPane().setGlassPane(glassPane);
  314.     }
  315.  
  316.  
  317. /////////////////
  318. // Accessibility support
  319. ////////////////
  320.  
  321.     protected AccessibleContext accessibleContext = null;
  322.  
  323.     /**
  324.      * Get the AccessibleContext associated with this JWindow
  325.      *
  326.      * @return the AccessibleContext of this JWindow
  327.      */
  328.     public AccessibleContext getAccessibleContext() {
  329.     if (accessibleContext == null) {
  330.         accessibleContext = new AccessibleJWindow();
  331.     }
  332.     return accessibleContext;
  333.     }
  334.  
  335.     protected class AccessibleJWindow extends AccessibleContext
  336.     implements Serializable, AccessibleComponent {
  337.  
  338.         // AccessibleContext methods
  339.         //
  340.         /**
  341.          * Get the role of this object.
  342.          *
  343.          * @return an instance of AccessibleRole describing the role of the 
  344.      * object
  345.          * @see AccessibleRole
  346.          */
  347.         public AccessibleRole getAccessibleRole() {
  348.         return AccessibleRole.WINDOW;
  349.         }
  350.  
  351.         /**
  352.          * Get the state of this object.
  353.          *
  354.          * @return an instance of AccessibleStateSet containing the current 
  355.      * state set of the object
  356.          * @see AccessibleState
  357.          */
  358.         public AccessibleStateSet getAccessibleStateSet() {
  359.            AccessibleStateSet states = SwingUtilities.getAccessibleStateSet(JWindow.this);
  360.         if (getFocusOwner() != null) {
  361.             states.add(AccessibleState.ACTIVE);
  362.         }
  363.         return states;
  364.         }
  365.  
  366.         /**
  367.          * Get the Accessible parent of this object.  If the parent of this
  368.          * object implements Accessible, this method should simply return
  369.          * getParent().
  370.          *
  371.          * @return the Accessible parent of this object -- can be null if this
  372.          * object does not have an Accessible parent
  373.          */
  374.         public Accessible getAccessibleParent() {
  375.             Container parent = getParent();
  376.             if (parent instanceof Accessible) {
  377.                 return (Accessible) parent;
  378.             } else {
  379.                 return null;
  380.             }
  381.         }
  382.  
  383.         /**
  384.          * Get the index of this object in its accessible parent. 
  385.          *
  386.          * @return the index of this object in its parent; -1 if this 
  387.          * object does not have an accessible parent.
  388.          * @see #getAccessibleParent
  389.          */
  390.         public int getAccessibleIndexInParent() {
  391.         return SwingUtilities.getAccessibleIndexInParent(JWindow.this);
  392.         }
  393.  
  394.         /**
  395.          * Returns the number of accessible children in the object.  If all
  396.          * of the children of this object implement Accessible, than this
  397.          * method should return the number of children of this object.
  398.          *
  399.          * @return the number of accessible children in the object.
  400.          */
  401.         public int getAccessibleChildrenCount() {
  402.         return SwingUtilities.getAccessibleChildrenCount(JWindow.this);
  403.         }
  404.  
  405.         /**
  406.          * Return the nth Accessible child of the object.  
  407.          *
  408.          * @param i zero-based index of child
  409.          * @return the nth Accessible child of the object
  410.          */
  411.         public Accessible getAccessibleChild(int i) {
  412.             return SwingUtilities.getAccessibleChild(JWindow.this,i);
  413.         }
  414.  
  415.         /**
  416.          * Return the locale of this object.
  417.      *
  418.          * @return the locale of this object
  419.          */
  420.         public Locale getLocale() {
  421.             return JWindow.this.getLocale();
  422.         }
  423.  
  424.         /**
  425.          * Get the AccessibleComponent associated with this object if one
  426.          * exists.  Otherwise return null.
  427.          */
  428.     public AccessibleComponent getAccessibleComponent() {
  429.         return this;
  430.     }
  431.  
  432.  
  433.         // AccessibleComponent methods
  434.         //
  435.         /**
  436.          * Get the background color of this object.
  437.          *
  438.          * @return the background color, if supported, of the object; 
  439.          * otherwise, null
  440.          */
  441.         public Color getBackground() {
  442.         return JWindow.this.getBackground();
  443.     }
  444.  
  445.         /**
  446.          * Set the background color of this object.
  447.          *
  448.          * @param c the new Color for the background
  449.          */
  450.         public void setBackground(Color c) {
  451.         JWindow.this.setBackground(c);
  452.     }
  453.  
  454.         /**
  455.          * Get the foreground color of this object.
  456.          *
  457.          * @return the foreground color, if supported, of the object; 
  458.          * otherwise, null
  459.          */
  460.         public Color getForeground() {
  461.         return JWindow.this.getForeground();
  462.     }
  463.  
  464.         /**
  465.          * Set the foreground color of this object.
  466.          *
  467.          * @param c the new Color for the foreground
  468.          */
  469.         public void setForeground(Color c) {
  470.         JWindow.this.setForeground(c);
  471.     }
  472.  
  473.         /**
  474.          * Get the Cursor of this object.
  475.          *
  476.          * @return the Cursor, if supported, of the object; otherwise, null
  477.          */
  478.         public Cursor getCursor() {
  479.         return JWindow.this.getCursor();
  480.     }
  481.  
  482.         /**
  483.          * Set the Cursor of this object.
  484.          *
  485.          * @param c the new Cursor for the object
  486.          */
  487.         public void setCursor(Cursor cursor) {
  488.         JWindow.this.setCursor(cursor);
  489.     }
  490.  
  491.         /**
  492.          * Get the Font of this object.
  493.          *
  494.          * @return the Font,if supported, for the object; otherwise, null
  495.          */
  496.         public Font getFont() {
  497.         return JWindow.this.getFont();
  498.     }
  499.  
  500.         /**
  501.          * Set the Font of this object.
  502.          *
  503.          * @param f the new Font for the object
  504.          */
  505.         public void setFont(Font f) {
  506.         JWindow.this.setFont(f);
  507.     }
  508.  
  509.         /**
  510.          * Get the FontMetrics of this object.
  511.          *
  512.          * @param f the Font
  513.          * @return the FontMetrics, if supported, the object; otherwise, null
  514.          * @see getFont
  515.          */
  516.         public FontMetrics getFontMetrics(Font f) {
  517.         return JWindow.this.getFontMetrics(f);
  518.     }
  519.  
  520.         /**
  521.          * Determine if the object is enabled.
  522.          *
  523.          * @return true if object is enabled; otherwise, false
  524.          */
  525.         public boolean isEnabled() {
  526.         return JWindow.this.isEnabled();
  527.     }
  528.  
  529.         /**
  530.          * Set the enabled state of the object.
  531.          *
  532.          * @param b if true, enables this object; otherwise, disables it 
  533.          */
  534.         public void setEnabled(boolean b) {
  535.         JWindow.this.setEnabled(b);
  536.     }
  537.     
  538.         /**
  539.          * Determine if the object is visible.  Note: this means that the
  540.          * object intends to be visible; however, it may not in fact be
  541.          * showing on the screen because one of the objects that this object
  542.          * is contained by is not visible.  To determine if an object is
  543.          * showing on the screen, use isShowing().
  544.          *
  545.          * @return true if object is visible; otherwise, false
  546.          */
  547.         public boolean isVisible() {
  548.         return JWindow.this.isVisible();
  549.     }
  550.  
  551.         /**
  552.          * Set the visible state of the object.
  553.          *
  554.          * @param b if true, shows this object; otherwise, hides it 
  555.          */
  556.         public void setVisible(boolean b) {
  557.         JWindow.this.setVisible(b);
  558.     }
  559.  
  560.         /**
  561.          * Determine if the object is showing.  This is determined by checking
  562.          * the visibility of the object and ancestors of the object.  Note: 
  563.      * this will return true even if the object is obscured by another 
  564.      * (for example, it happens to be underneath a menu that was pulled 
  565.      * down).
  566.          *
  567.          * @return true if object is showing; otherwise, false
  568.          */
  569.         public boolean isShowing() {
  570.         return JWindow.this.isShowing();
  571.     }
  572.  
  573.         /** 
  574.          * Checks whether the specified point is within this object's bounds,
  575.          * where the point's x and y coordinates are defined to be relative to 
  576.      * the coordinate system of the object. 
  577.          *
  578.          * @param p the Point relative to the coordinate system of the object
  579.          * @return true if object contains Point; otherwise false
  580.          */
  581.         public boolean contains(Point p) {
  582.         return JWindow.this.contains(p);
  583.     }
  584.     
  585.         /** 
  586.          * Returns the location of the object on the screen.
  587.          *
  588.          * @return location of object on screen -- can be null if this object
  589.          * is not on the screen
  590.          */
  591.         public Point getLocationOnScreen() {
  592.         return JWindow.this.getLocationOnScreen();
  593.     }
  594.  
  595.         /** 
  596.          * Gets the location of the object relative to the parent in the form 
  597.          * of a point specifying the object's top-left corner in the screen's 
  598.          * coordinate space.
  599.          *
  600.          * @return An instance of Point representing the top-left corner of 
  601.      * the objects's bounds in the coordinate space of the screen; null if
  602.          * this object or its parent are not on the screen
  603.          */
  604.     public Point getLocation() {
  605.         return JWindow.this.getLocation();
  606.     }
  607.  
  608.         /** 
  609.          * Sets the location of the object relative to the parent.
  610.          */
  611.         public void setLocation(Point p) {
  612.         JWindow.this.setLocation(p);
  613.     }
  614.  
  615.         /** 
  616.          * Gets the bounds of this object in the form of a Rectangle object. 
  617.          * The bounds specify this object's width, height, and location
  618.          * relative to its parent. 
  619.          *
  620.          * @return A rectangle indicating this component's bounds; null if 
  621.      * this object is not on the screen.
  622.          */
  623.         public Rectangle getBounds() {
  624.         return JWindow.this.getBounds();
  625.     }
  626.  
  627.         /** 
  628.          * Sets the bounds of this object in the form of a Rectangle object. 
  629.          * The bounds specify this object's width, height, and location
  630.          * relative to its parent.
  631.          *    
  632.          * @param A rectangle indicating this component's bounds
  633.          */
  634.         public void setBounds(Rectangle r) {
  635.         JWindow.this.setBounds(r);
  636.     }
  637.  
  638.         /** 
  639.          * Returns the size of this object in the form of a Dimension object. 
  640.          * The height field of the Dimension object contains this objects's
  641.          * height, and the width field of the Dimension object contains this 
  642.      * object's width. 
  643.          *
  644.          * @return A Dimension object that indicates the size of this 
  645.      * component; null if this object is not on the screen
  646.          */
  647.         public Dimension getSize() {
  648.         return JWindow.this.getSize();
  649.     }
  650.  
  651.         /** 
  652.          * Resizes this object so that it has width width and height. 
  653.          *    
  654.          * @param d - The dimension specifying the new size of the object. 
  655.          */
  656.         public void setSize(Dimension d) {
  657.         JWindow.this.setSize(d);
  658.     }
  659.  
  660.         /**
  661.          * Returns the Accessible child, if one exists, contained at the local
  662.      * coordinate Point.
  663.          *
  664.          * @param p The point defining the top-left corner of the Accessible, 
  665.      * given in the coordinate space of the object's parent. 
  666.          * @return the Accessible, if it exists, at the specified location; 
  667.      * else null
  668.          */
  669.         public Accessible getAccessibleAt(Point p) {
  670.         return SwingUtilities.getAccessibleAt(JWindow.this,p);
  671.     }
  672.  
  673.         /**
  674.          * Returns whether this object can accept focus or not.
  675.          *
  676.          * @return true if object can accept focus; otherwise false
  677.          */
  678.         public boolean isFocusTraversable() {
  679.         return JWindow.this.isFocusTraversable();
  680.     }
  681.  
  682.         /**
  683.          * Requests focus for this object.
  684.          */
  685.         public void requestFocus() {
  686.         JWindow.this.requestFocus();
  687.         }
  688.  
  689.         /**
  690.          * Adds the specified focus listener to receive focus events from this 
  691.          * component. 
  692.          *
  693.          * @param l the focus listener
  694.          */
  695.         public void addFocusListener(FocusListener l) {
  696.         JWindow.this.addFocusListener(l);
  697.     }
  698.  
  699.         /**
  700.          * Removes the specified focus listener so it no longer receives focus 
  701.          * events from this component.
  702.          *
  703.          * @param l the focus listener
  704.          */
  705.         public void removeFocusListener(FocusListener l) {
  706.         JWindow.this.removeFocusListener(l);
  707.     }
  708.     } // inner class AccessibleJWindow
  709. }
  710.  
  711.