home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgLangD.iso / VCAFE.3.0A / Main.bin / JPluginFrame.java < prev    next >
Text File  |  1998-10-25  |  13KB  |  426 lines
  1. /*
  2.  * Copyright 1998 Symantec Corporation, All Rights Reserved.
  3.  */
  4.  
  5. package com.symantec.itools.vcafe.openapi.pluginapi;
  6.  
  7. import java.awt.*;
  8. import java.util.*;
  9. import java.awt.event.*;
  10. import com.sun.java.swing.*;
  11.  
  12. /**
  13.  * The API used to integrate a frame window into Visual Cafe
  14.  * @see PluginFrame
  15.  *
  16.  * @author Symantec Internet Tools Division
  17.  * @version 1.0
  18.  * @since VCafe 3.0
  19.  */
  20. public class JPluginFrame extends PluginFrame implements WindowConstants, RootPaneContainer
  21. {    
  22.     private int defaultCloseOperation = HIDE_ON_CLOSE;
  23.  
  24.     /**
  25.      * The JRootPane instance that manages the <code>contentPane</code> 
  26.      * and optional <code>menuBar</code> for this frame, as well as the 
  27.      * <code>glassPane</code>.
  28.      *
  29.      * @see JRootPane
  30.      * @see RootPaneContainer
  31.      */
  32.     protected JRootPane rootPane;
  33.  
  34.     /**
  35.      * If true then calls to <code>add</code> and <code>setLayout</code>
  36.      * cause an exception to be thrown.
  37.      *
  38.      * @see #isRootPaneCheckingEnabled
  39.      * @see #setRootPaneCheckingEnabled
  40.      */
  41.     protected boolean rootPaneCheckingEnabled = false;
  42.  
  43.  
  44.     /**
  45.      * Constructs a new Frame that is initially invisible.
  46.      *
  47.      * @see Component#setSize
  48.      * @see Component#setVisible
  49.      */
  50.     public JPluginFrame()
  51.     {
  52.         super();        
  53.         frameInit();
  54.     }
  55.  
  56.     /**
  57.      * Constructs a new, initially invisible Frame with the specified
  58.      * title.
  59.      *
  60.      * @param title the title for the frame
  61.      * @see Component#setSize
  62.      * @see Component#setVisible
  63.      */
  64.     public JPluginFrame(String title)
  65.     {
  66.         super(title);
  67.         frameInit();
  68.     }
  69.  
  70.     /** Called by the constructors to init the JPluginFrame properly. */
  71.     protected void frameInit()
  72.     {
  73.         enableEvents(AWTEvent.KEY_EVENT_MASK | AWTEvent.WINDOW_EVENT_MASK);
  74.         setRootPane(createRootPane());
  75.         setBackground(UIManager.getColor("control"));
  76.         setRootPaneCheckingEnabled(true);
  77.     }
  78.  
  79.     /** Called by the constructor methods to create the default rootPane. */
  80.     protected JRootPane createRootPane()
  81.     {
  82.         return new JRootPane();
  83.     }
  84.  
  85.     /** 
  86.      * Processes key events occurring on this component and, if appropriate,
  87.      * passes them on to components in the frame which have registered 
  88.      * interest in them.
  89.      *
  90.      * @param  e  the key event
  91.      * @see    java.awt.Component#processKeyEvent
  92.      */   
  93.     protected void processKeyEvent(KeyEvent e)
  94.     {
  95.         super.processKeyEvent(e);
  96.         if(!e.isConsumed())
  97.         {
  98.             JComponentHelper.processKeyBindingsForAllComponents(e,this,new Vector(),e.getID() == KeyEvent.KEY_PRESSED);
  99.         }
  100.     }
  101.  
  102.     /** 
  103.      * Processes window events occurring on this component.
  104.      * Hides the window or disposes of it, as specified by the setting
  105.      * of the <code>defaultCloseOperation</code> property.
  106.      *
  107.      * @param  e  the window event
  108.      * @see    #setDefaultCloseOperation
  109.      * @see    java.awt.Window#processWindowEvent
  110.      */
  111.     protected void processWindowEvent(WindowEvent e)
  112.     {
  113.         super.processWindowEvent(e);
  114.  
  115.         if (e.getID() == WindowEvent.WINDOW_CLOSING)
  116.         {
  117.             switch(defaultCloseOperation)
  118.             {
  119.                 case HIDE_ON_CLOSE:
  120.                     setVisible(false);
  121.                     break;
  122.                 case DISPOSE_ON_CLOSE:
  123.                     setVisible(false);
  124.                     dispose();
  125.                     break;
  126.                 case DO_NOTHING_ON_CLOSE:
  127.                 default: 
  128.                     break;
  129.             }
  130.         }
  131.     }
  132.  
  133.     /**
  134.      * Sets the operation which will happen by default when
  135.      * the user initiates a "close" on this frame.
  136.      * The possible choices are:
  137.      * <p>
  138.      * <ul>
  139.      * <li>DO_NOTHING_ON_CLOSE - do not do anything - require the
  140.      * program to handle the operation in the windowClosing
  141.      * method of a registered WindowListener object.
  142.      * <li>HIDE_ON_CLOSE - automatically hide the frame after
  143.      * invoking any registered WindowListener objects
  144.      * <li>DISPOSE_ON_CLOSE - automatically hide and dispose the 
  145.      * frame after invoking any registered WindowListener objects
  146.      * </ul>
  147.      * <p>
  148.      * The value is set to HIDE_ON_CLOSE by default.
  149.      * @see java.awt.Window#addWindowListener
  150.      * @see #getDefaultCloseOperation
  151.      *
  152.      * @beaninfo
  153.      *   preferred: true
  154.      *        enum: DO_NOTHING_ON_CLOSE WindowConstants.DO_NOTHING_ON_CLOSE
  155.      *              HIDE_ON_CLOSE       WindowConstants.HIDE_ON_CLOSE
  156.      *              DISPOSE_ON_CLOSE    WindowConstants.DISPOSE_ON_CLOSE
  157.      * description: The frame's default close operation.
  158.      */
  159.     public void setDefaultCloseOperation(int operation)
  160.     {
  161.         this.defaultCloseOperation = operation;
  162.     }
  163.  
  164.  
  165.    /**
  166.     * Returns the operation which occurs when the user
  167.     * initiates a "close" on this frame.
  168.     *
  169.     * @return an int indicating the window-close operation
  170.     * @see #setDefaultCloseOperation
  171.     */
  172.     public int getDefaultCloseOperation()
  173.     {
  174.         return defaultCloseOperation;
  175.     }
  176.  
  177.  
  178.     /** 
  179.      * Just calls <code>paint(g)</code>.  This method was overridden to 
  180.      * prevent an unneccessary call to clear the background.
  181.      *
  182.      * @param g the Graphics context in which to paint
  183.      */
  184.     public void update(Graphics g)
  185.     {
  186.         paint(g);
  187.     }
  188.  
  189.     /**
  190.      * Returns whether calls to <code>add</code> and 
  191.      * <code>setLayout</code> cause an exception to be thrown. 
  192.      *
  193.      * @return true if <code>add</code> and <code>setLayout</code> 
  194.      *         are checked
  195.      *
  196.      * @see #addImpl
  197.      * @see #setLayout
  198.      * @see #setRootPaneCheckingEnabled
  199.      */
  200.     protected boolean isRootPaneCheckingEnabled()
  201.     {
  202.         return rootPaneCheckingEnabled;
  203.     }
  204.  
  205.     /**
  206.      * Determines whether calls to <code>add</code> and 
  207.      * <code>setLayout</code> cause an exception to be thrown. 
  208.      * 
  209.      * @param enabled  a boolean value, true if checking is to be
  210.      *        enabled, which cause the exceptions to be thrown
  211.      *
  212.      * @see #addImpl
  213.      * @see #setLayout
  214.      * @see #isRootPaneCheckingEnabled
  215.      * @beaninfo
  216.      *      hidden: true
  217.      * description: Whether the add and setLayout methods throw exceptions when invoked.
  218.      */
  219.     protected void setRootPaneCheckingEnabled(boolean enabled)
  220.     {
  221.         rootPaneCheckingEnabled = enabled;
  222.     }
  223.  
  224.  
  225.     /**
  226.      * Creates a runtime exception with a message like:
  227.      * <pre>
  228.      * "Do not use JPluginFrame.add() use JPluginFrame.getContentPane().add() instead"
  229.      * </pre>
  230.      *
  231.      * @param op  a String indicating the attempted operation. In the
  232.      *            example above, the operation string is "add"
  233.      */
  234.     private Error createRootPaneException(String op)
  235.     {
  236.         String type = getClass().getName();
  237.         return new Error(
  238.             "Do not use " + type + "." + op + "() use " 
  239.                           + type + ".getContentPane()." + op + "() instead");
  240.     }
  241.  
  242.  
  243.     /**
  244.      * By default, children may not be added directly to a this component,
  245.      * they must be added to its contentPane instead.  For example:
  246.      * <pre>
  247.      * thisComponent.getContentPane().add(child)
  248.      * </pre>
  249.      * An attempt to add to directly to this component will cause an
  250.      * runtime exception to be thrown.  Subclasses can disable this
  251.      * behavior.
  252.      * 
  253.      * @see #setRootPaneCheckingEnabled
  254.      * @exception Error if called with rootPaneChecking true
  255.      */
  256.     protected void addImpl(Component comp, Object constraints, int index) 
  257.     {
  258.         if(isRootPaneCheckingEnabled())
  259.         {
  260.             throw createRootPaneException("add");
  261.         }
  262.         else
  263.         {
  264.             super.addImpl(comp, constraints, index);
  265.         }
  266.     }
  267.  
  268.  
  269.     /**
  270.      * By default the layout of this component may not be set,
  271.      * the layout of its contentPane should be set instead.  
  272.      * For example:
  273.      * <pre>
  274.      * thiComponent.getContentPane().setLayout(new BorderLayout())
  275.      * </pre>
  276.      * An attempt to set the layout of this component will cause an
  277.      * runtime exception to be thrown.  Subclasses can disable this
  278.      * behavior.
  279.      * 
  280.      * @see #setRootPaneCheckingEnabled
  281.      * @exception Error if called with rootPaneChecking true
  282.      */
  283.     public void setLayout(LayoutManager manager)
  284.     {
  285.         if(isRootPaneCheckingEnabled())
  286.         {
  287.             throw createRootPaneException("setLayout");
  288.         }
  289.         else
  290.         {
  291.             super.setLayout(manager);
  292.         }
  293.     }
  294.  
  295.  
  296.     /**
  297.      * Returns the rootPane object for this frame.
  298.      *
  299.      * @see #setRootPane
  300.      * @see RootPaneContainer#getRootPane
  301.      */
  302.     public JRootPane getRootPane()
  303.     { 
  304.         return rootPane; 
  305.     }
  306.  
  307.     /**
  308.      * Sets the rootPane property.  This method is called by the constructor.
  309.      * @param root the rootPane object for this frame
  310.      *
  311.      * @see #getRootPane
  312.      *
  313.      * @beaninfo
  314.      *   hidden: true
  315.      * description: the RootPane object for this frame.
  316.      */
  317.     protected void setRootPane(JRootPane root) 
  318.     {
  319.         if(rootPane != null)
  320.         {
  321.             remove(rootPane);
  322.         }
  323.         rootPane = root;
  324.         if(rootPane != null)
  325.         {
  326.             boolean checkingEnabled = isRootPaneCheckingEnabled();
  327.             try
  328.             {
  329.                 setRootPaneCheckingEnabled(false);
  330.                 add(rootPane, BorderLayout.CENTER);
  331.             }
  332.             finally
  333.             {
  334.                 setRootPaneCheckingEnabled(checkingEnabled);
  335.             }
  336.         }
  337.     }
  338.  
  339.  
  340.     /**
  341.      * Returns the contentPane object for this frame.
  342.      *
  343.      * @see #setContentPane
  344.      * @see RootPaneContainer#getContentPane
  345.      */
  346.     public Container getContentPane()
  347.     { 
  348.         return getRootPane().getContentPane(); 
  349.     }
  350.  
  351.     /**
  352.      * Sets the contentPane property.  This method is called by the constructor.
  353.      * @param contentPane the contentPane object for this frame
  354.      *
  355.      * @exception java.awt.IllegalComponentStateException (a runtime
  356.      *            exception) if the content pane parameter is null
  357.      * @see #getContentPane
  358.      * @see RootPaneContainer#setContentPane
  359.      *
  360.      * @beaninfo
  361.      *     hidden: true
  362.      *     description: The client area of the frame where child 
  363.      *                  components are normally inserted.
  364.      */
  365.     public void setContentPane(Container contentPane)
  366.     {
  367.         getRootPane().setContentPane(contentPane);
  368.     }
  369.  
  370.     /**
  371.      * Returns the layeredPane object for this frame.
  372.      *
  373.      * @see #setLayeredPane
  374.      * @see RootPaneContainer#getLayeredPane
  375.      */
  376.     public JLayeredPane getLayeredPane()
  377.     { 
  378.         return getRootPane().getLayeredPane(); 
  379.     }
  380.  
  381.     /**
  382.      * Sets the layeredPane property.  This method is called by the constructor.
  383.      * @param layeredPane the layeredPane object for this frame
  384.      *
  385.      * @exception java.awt.IllegalComponentStateException (a runtime
  386.      *            exception) if the layered pane parameter is null
  387.      * @see #getLayeredPane
  388.      * @see RootPaneContainer#setLayeredPane
  389.      *
  390.      * @beaninfo
  391.      *     hidden: true
  392.      *     description: The pane which holds the various frame layers.
  393.      */
  394.     public void setLayeredPane(JLayeredPane layeredPane)
  395.     {
  396.         getRootPane().setLayeredPane(layeredPane);
  397.     }
  398.  
  399.     /**
  400.      * Returns the glassPane object for this frame.
  401.      *
  402.      * @see #setGlassPane
  403.      * @see RootPaneContainer#getGlassPane
  404.      */
  405.     public Component getGlassPane()
  406.     { 
  407.         return getRootPane().getGlassPane(); 
  408.     }
  409.  
  410.     /**
  411.      * Sets the glassPane property. 
  412.      * This method is called by the constructor.
  413.      * @param glassPane the glassPane object for this frame
  414.      *
  415.      * @see #getGlassPane
  416.      * @see RootPaneContainer#setGlassPane
  417.      *
  418.      * @beaninfo
  419.      *     hidden: true
  420.      *     description: A transparent pane used for menu rendering.
  421.      */
  422.     public void setGlassPane(Component glassPane)
  423.     {
  424.         getRootPane().setGlassPane(glassPane);
  425.     }    
  426. }