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