home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgLangD.iso / VCAFE.3.0A / Main.bin / SimpleWizardController.java < prev    next >
Text File  |  1998-10-21  |  17KB  |  610 lines
  1. /*
  2.  * SimpleWizardController.java
  3.  */
  4.  
  5. package symantec.itools.awt;
  6.  
  7. import java.awt.Component;
  8. import java.util.Vector;
  9.  
  10. /**
  11.  * SimpleWizardController implements the WizardController interface.
  12.  * It is the default WizardController used by Wizard and provides
  13.  * a simple behaviour that can be easily overriden. It manages a stack
  14.  * containing the history of pages shown, and provides consistent
  15.  * defaults for the navigation buttons.
  16.  */
  17.  
  18. public class SimpleWizardController implements WizardController
  19. {
  20.     /**
  21.      * Create a SimpleWizardController.
  22.      *
  23.      * @param wizard
  24.      * A WizardInterface to talk to.
  25.      */
  26.     public SimpleWizardController(WizardInterface wizard)
  27.     {
  28.         //debug("SimpleWizardController");
  29.         this.wizard = wizard;
  30.     }
  31.  
  32.     /**
  33.      * Called before the first page is shown.
  34.      * Default behavior: clean-up the history stack.
  35.      */
  36.     public void doPrepare()
  37.     {
  38.         stack.removeAllElements();
  39.     }
  40.  
  41.     /**
  42.      * Called before the first page is shown in the special case of
  43.      * this SimpleWizardController.
  44.      * Default behavior: clean-up the history stack and stack the first
  45.      * pages.
  46.      */
  47.     public void doPrepare(int index)
  48.     {
  49.         doPrepare();
  50.         for (int i = 0; i < index; i++)
  51.             stack.addElement(wizard.getComponentAt(i));
  52.     }
  53.  
  54.     /**
  55.      * Called before a page is shown.
  56.      * Default behavior: add the page to the history stack if the action is
  57.      * NEXT, remove the last page from the history stack if the action is
  58.      * PREVIOUS.
  59.      *
  60.      * @param comp
  61.      * The page that will be shown.
  62.      * @param action
  63.      * The action that has led to this page, either PREVIOUS or NEXT. If it is
  64.      * the first page of the wizard, the action is NEXT.
  65.      * @see #getPreviousPage
  66.      */
  67.     public void preparePage(Component comp, int action)
  68.     {
  69.         //debug("preparePage");
  70.         // Don't maintain a stack at design time
  71.  
  72.         if (!getIgnoreDesignTime() && java.beans.Beans.isDesignTime())
  73.             return;
  74.  
  75.         if (action == NEXT)
  76.         {
  77.             stack.addElement(comp);
  78.             //System.err.println("Added element, comp = " + comp.hashCode());
  79.         }
  80.         else if (action == PREVIOUS)
  81.         {
  82.             if (stack.size() > 0) {
  83.                 //System.err.println("preparePage removeElementAt");
  84.                 stack.removeElementAt(stack.size() - 1);
  85.                 //System.err.println("Removed element, comp = " + comp.hashCode());
  86.             }
  87.         }
  88.     }
  89.  
  90.     /**
  91.      * Called after a page is shown.
  92.      * Default behavior: none.
  93.      *
  94.      * @param comp
  95.      * The page that has been shown.
  96.      */
  97.     public void pageShown(Component comp)
  98.     {
  99.         //debug("pageShown");
  100.         // do nothing
  101.     }
  102.  
  103.     /**
  104.      * Try to validate a page.
  105.      * Default behavior: return the state of the button associated with
  106.      * the action, using the isXxxEnabled methods. For example, if the
  107.      * controller has the Previous button enabled, this method will return
  108.      * true, meaning that it is valid to go back.
  109.      * If the result is true, then the Wizard will proceed with the
  110.      * action, else the state will not change.
  111.      *
  112.      * @param comp
  113.      * The page that must be validated.
  114.      * @param target
  115.      * The page that will be shown if the action is PREVIOUS or NEXT, null
  116.      * otherwise.
  117.      * @param action
  118.      * The action that must be validated, PREVIOUS, NEXT, FINISH, CANCEL or HELP.
  119.      * @return
  120.      * True if the action is validated, false otherwise.
  121.      */
  122.     public boolean validatePage(Component comp, Component target, int action)
  123.     {
  124.         //debug("validatePage");
  125.         switch(action)
  126.         {
  127.             case NEXT:
  128.                 return isNextEnabled();
  129.             case PREVIOUS:
  130.                 return isPreviousEnabled();
  131.             case FINISH:
  132.                 return isFinishEnabled();
  133.             case CANCEL:
  134.                 return isCancelEnabled();
  135.             case HELP:
  136.                 return isHelpEnabled();
  137.             default:
  138.                 return false;
  139.         }
  140.     }
  141.  
  142.     /**
  143.      * Called before the page is hidden.
  144.      * Default behavior: none.
  145.      *
  146.      * @param comp
  147.      * The page that has been shown.
  148.      */
  149.     public void pageHidden(Component comp)
  150.     {
  151.         //debug("pageHidden");
  152.         // do nothing
  153.     }
  154.  
  155.     /**
  156.      * Called when the FINISH action has been validated.
  157.      * Default behavior: none.
  158.      */
  159.     public void doFinish()
  160.     {
  161.         //debug("doFinish");
  162.         // do nothing
  163.     }
  164.  
  165.     /**
  166.      * Called when the CANCEL action has been validated.
  167.      * Default behavior: none.
  168.      */
  169.     public void doCancel()
  170.     {
  171.         //debug("doCancel");
  172.         // do nothing
  173.     }
  174.  
  175.     /**
  176.      * Called when the HELP action has been validated.
  177.      * Default behavior: none.
  178.      */
  179.     public void doHelp()
  180.     {
  181.         //debug("doHelp");
  182.         // do nothing
  183.     }
  184.  
  185.     /**
  186.      * Tells if the Previous button must be enabled.
  187.      * Default behavior: if setPreviousEnabled has been called,
  188.      * return that value. Else return true if the getPreviousPage method
  189.      * returns a page, false otherwise.
  190.      *
  191.      * @return
  192.      * True if the Previous button must be enabled, false otherwise.
  193.      */
  194.     public boolean isPreviousEnabled()
  195.     {
  196.         if (previousEnabled == 0)
  197.             return false;
  198.         else if (previousEnabled == 1)
  199.             return true;
  200.  
  201.         return (getPreviousPage() != null);
  202.     }
  203.  
  204.     /**
  205.      * Tells if the Next button must be enabled.
  206.      * Default behavior: if setNextEnabled has been called,
  207.      * return that value. Else return true if the getNextPage method
  208.      * returns a page, false otherwise.
  209.      *
  210.      * @return
  211.      * True if the Next button must be enabled, false otherwise.
  212.      */
  213.     public boolean isNextEnabled()
  214.     {
  215.         if (nextEnabled == 0)
  216.             return false;
  217.         else if (nextEnabled == 1)
  218.             return true;
  219.  
  220.         return (getNextPage() != null);
  221.     }
  222.  
  223.     /**
  224.      * Tells if the Finish button must be enabled.
  225.      * Default behavior: if setFinishEnabled has been called,
  226.      * return that value. Else return true if the current page
  227.      * is the last page in the Wizard container.
  228.      *
  229.      * @return
  230.      * True if the Finish button must be enabled, false otherwise.
  231.      */
  232.     public boolean isFinishEnabled()
  233.     {
  234.         if (finishEnabled == 0)
  235.             return false;
  236.         else if (finishEnabled == 1)
  237.             return true;
  238.  
  239.         int current = wizard.getSelectedIndex();
  240.         int count = wizard.getPageCount();
  241.  
  242.         if (getIgnoreDesignTime() || !java.beans.Beans.isDesignTime())
  243.         {
  244.             if ((count > 0) && (current != -1))
  245.                 return (current == (count - 1));
  246.             else
  247.                 return false;
  248.         }
  249.         else
  250.         {
  251.             return false;
  252.         }
  253.     }
  254.  
  255.     /**
  256.      * Tells if the Cancel button must be enabled.
  257.      * Default behavior: if setCancelEnabled has been called,
  258.      * return that value. Else return true.
  259.      *
  260.      * @return
  261.      * True if the Cancel button must be enabled, false otherwise.
  262.      */
  263.     public boolean isCancelEnabled()
  264.     {
  265.         if (cancelEnabled == 0)
  266.             return false;
  267.         else if (cancelEnabled == 1)
  268.             return true;
  269.  
  270.         if (!getIgnoreDesignTime() && java.beans.Beans.isDesignTime())
  271.             return false;
  272.         else
  273.             return true;
  274.     }
  275.  
  276.     /**
  277.      * Tells if the Help button must be enabled.
  278.      * Default behavior: if setHelpEnabled has been called,
  279.      * return that value. Else return true.
  280.      *
  281.      * @return
  282.      * True if the Help button must be enabled, false otherwise.
  283.      */
  284.     public boolean isHelpEnabled()
  285.     {
  286.         if (helpEnabled == 0)
  287.             return false;
  288.         else if (helpEnabled == 1)
  289.             return true;
  290.  
  291.         if (!getIgnoreDesignTime() && java.beans.Beans.isDesignTime())
  292.             return false;
  293.         else
  294.             return true;
  295.     }
  296.  
  297.     /**
  298.      * Return the previous page.
  299.      * Default behavior: if a previous page has been set with
  300.      * setPreviousPage, return this page. If a previous page index has
  301.      * been set with setPreviousPageIndex, return the associated page.
  302.      * Else, return the next to last element on the stack. If there is none,
  303.      * return null.
  304.      * This method is called before and after a validatePage, and by the
  305.      * default implementation of isPreviousEnabled.
  306.      *
  307.      * @return
  308.      * The previous page to show, null if there is none.
  309.      * @see #setPreviousPage
  310.      * @see #setPreviousPageIndex
  311.      * @see #preparePage
  312.      */
  313.     public Component getPreviousPage()
  314.     {
  315.         if (getIgnoreDesignTime() || !java.beans.Beans.isDesignTime())
  316.         {
  317.             if (previousPage != null)
  318.                 return previousPage;
  319.             else if (previousPageIndex != -1)
  320.                 return wizard.getComponentAt(previousPageIndex);
  321.             else if (stack.size() > 1)
  322.                 return (Component)stack.elementAt(stack.size() - 2);
  323.             else
  324.                 return null;
  325.         }
  326.         else
  327.         {
  328.             int current = wizard.getSelectedIndex();
  329.             int count = wizard.getPageCount();
  330.  
  331.             if ((count > 0) && (current > 0))
  332.                 return wizard.getComponentAt(current - 1);
  333.             else
  334.                 return null;
  335.  
  336.         }
  337.     }
  338.  
  339.     /**
  340.      * Return the next page.
  341.      * Default behavior: if a next page has been set with
  342.      * setNextPage, return this page. If a next page index has
  343.      * been set with setNextPageIndex, return the associated page.
  344.      * Else, return the next page in the Wizard components order,
  345.      * page 0 if no page has been shown.
  346.      * If there is none, return null.
  347.      * This method is called before and after a validatePage, and by the
  348.      * default implementation of isNextEnabled.
  349.      *
  350.      * @return
  351.      * The next page to show, null if there is none.
  352.      * @see #setNextPage
  353.      * @see #setNextPageIndex
  354.      */
  355.     public Component getNextPage()
  356.     {
  357.         int current = wizard.getSelectedIndex();
  358.         int count = wizard.getPageCount();
  359.  
  360.         if (getIgnoreDesignTime() || !java.beans.Beans.isDesignTime())
  361.         {
  362.             if (nextPage != null)
  363.                 return nextPage;
  364.             else if (nextPageIndex != -1)
  365.                 return wizard.getComponentAt(nextPageIndex);
  366.             else if ((count > 0) && (current != -1) && (current != (count - 1)))
  367.                 return wizard.getComponentAt(current + 1);
  368.             else if ((count > 0) && (current == -1))
  369.                 return wizard.getComponentAt(0);
  370.             else
  371.                 return null;
  372.         }
  373.         else
  374.         {
  375.             if ((count > 0) && (current != -1) && (current != (count - 1)))
  376.                 return wizard.getComponentAt(current + 1);
  377.             else
  378.                 return null;
  379.         }
  380.     }
  381.  
  382.     // Explicit chain information provided by interactions
  383.  
  384.     /**
  385.      * Set an index for the previous page.
  386.      * This index is used by the default implementation of getPreviousPage.
  387.      * It is reset before a new page is prepared.
  388.      *
  389.      * @see #getPreviousPage
  390.      * @see #resetChainInfo
  391.      */
  392.     public void setPreviousPageIndex(int index)
  393.     {
  394.         previousPageIndex = index;
  395.     }
  396.  
  397.     /**
  398.      * Set an index for the next page.
  399.      * This index is used by the default implementation of getNextPage.
  400.      * It is reset before a new page is prepared.
  401.      *
  402.      * @see #getNextPage
  403.      * @see #resetChainInfo
  404.      */
  405.     public void setNextPageIndex(int index)
  406.     {
  407.         nextPageIndex = index;
  408.     }
  409.  
  410.     /**
  411.      * Set a previous page.
  412.      * This page is used by the default implementation of getPreviousPage.
  413.      * It is reset before a new page is prepared.
  414.      *
  415.      * @see #getPreviousPage
  416.      * @see #resetChainInfo
  417.      */
  418.     public void setPreviousPage(Component comp)
  419.     {
  420.         previousPage = comp;
  421.     }
  422.  
  423.     /**
  424.      * Set a next page.
  425.      * This page is used by the default implementation of getNextPage.
  426.      * It is reset before a new page is prepared.
  427.      *
  428.      * @see #getNextPage
  429.      * @see #resetChainInfo
  430.      */
  431.     public void setNextPage(Component comp)
  432.     {
  433.         nextPage = comp;
  434.     }
  435.  
  436.     /**
  437.      * Set the state of the Previous button.
  438.      * This state is used by the default implementation of isPreviousEnabled.
  439.      * It is reset before a new page is prepared.
  440.      *
  441.      * @see #isPreviousEnabled
  442.      * @see #resetChainInfo
  443.      */
  444.     public void setPreviousEnabled(boolean status)
  445.     {
  446.         previousEnabled = status ? 1 : 0;
  447.         wizard.updateButtonsState();
  448.     }
  449.  
  450.     /**
  451.      * Set the state of the Next button.
  452.      * This state is used by the default implementation of isNextEnabled.
  453.      * It is reset before a new page is prepared.
  454.      *
  455.      * @see #isNextEnabled
  456.      * @see #resetChainInfo
  457.      */
  458.     public void setNextEnabled(boolean status)
  459.     {
  460.         nextEnabled = status ? 1 : 0;
  461.         wizard.updateButtonsState();
  462.     }
  463.  
  464.     /**
  465.      * Set the state of the Finish button.
  466.      * This state is used by the default implementation of isFinishEnabled.
  467.      * It is reset before a new page is prepared.
  468.      *
  469.      * @see #isFinishEnabled
  470.      * @see #resetChainInfo
  471.      */
  472.     public void setFinishEnabled(boolean status)
  473.     {
  474.         finishEnabled = status ? 1 : 0;
  475.         wizard.updateButtonsState();
  476.     }
  477.  
  478.     /**
  479.      * Set the state of the Cancel button.
  480.      * This state is used by the default implementation of isCancelEnabled.
  481.      * It is reset before a new page is prepared.
  482.      *
  483.      * @see #isCancelEnabled
  484.      * @see #resetChainInfo
  485.      */
  486.     public void setCancelEnabled(boolean status)
  487.     {
  488.         cancelEnabled = status ? 1 : 0;
  489.         wizard.updateButtonsState();
  490.     }
  491.  
  492.     /**
  493.      * Set the state of the Help button.
  494.      * This state is used by the default implementation of isHelpEnabled.
  495.      * It is reset before a new page is prepared.
  496.      *
  497.      * @see #isHelpEnabled
  498.      * @see #resetChainInfo
  499.      */
  500.     public void setHelpEnabled(boolean status)
  501.     {
  502.         helpEnabled = status ? 1 : 0;
  503.         wizard.updateButtonsState();
  504.     }
  505.  
  506.     /**
  507.      * Reset the chain information set by setPreviousPageIndex,
  508.      * setNextPageIndex, setPreviousPage, setNextPage, and
  509.      * setXxxEnabled. This is called before a new page is preared.
  510.      *
  511.      * @see #setPreviousPageIndex
  512.      * @see #setNextPageIndex
  513.      * @see #setPreviousPage
  514.      * @see #setNextPage
  515.      */
  516.     public void resetChainInfo()
  517.     {
  518.         previousPage = null;
  519.         previousPageIndex = -1;
  520.         nextPage = null;
  521.         nextPageIndex = -1;
  522.  
  523.         previousEnabled = -1;
  524.         nextEnabled = -1;
  525.         finishEnabled = -1;
  526.         cancelEnabled = -1;
  527.         helpEnabled = -1;
  528.     }
  529.     
  530.     // Member variables
  531.  
  532.     /**
  533.      * The WizardInterface.
  534.      */
  535.     protected WizardInterface wizard;
  536.     /**
  537.      * The stack containing the history of the pages shown.
  538.      *
  539.      * @see #preparePage
  540.      * @see #getPreviousPage
  541.      */
  542.     protected Vector stack = new Vector();
  543.  
  544.     /**
  545.      * The index of the previous ("back") page, or -1 if none.
  546.      * @see #setPreviousPageIndex
  547.      */
  548.     protected int previousPageIndex = -1;
  549.     /**
  550.      * The index of the next page, or -1 if none.
  551.      * @see #setNextPageIndex
  552.      */
  553.     protected int nextPageIndex = -1;
  554.  
  555.     /**
  556.      * The previous ("back") page, or <code>null</code> if none.
  557.      * @see #setPreviousPage
  558.      */
  559.     protected Component previousPage;
  560.     /**
  561.      * The next page, or <code>null</code> if none.
  562.      * @see #setNextPage
  563.      */
  564.     protected Component nextPage;
  565.  
  566.     /**
  567.      * True if the Previous button is enabled.
  568.      */
  569.     protected int previousEnabled = -1;
  570.     /**
  571.      * True if the Next button is enabled.
  572.      */
  573.     protected int nextEnabled = -1;
  574.     /**
  575.      * True if the Finish button is enabled.
  576.      */
  577.     protected int finishEnabled = -1;
  578.     /**
  579.      * True if the Cancel button is enabled.
  580.      */
  581.     protected int cancelEnabled = -1;
  582.     /**
  583.      * True if the Help button is enabled.
  584.      */
  585.     protected int helpEnabled = -1;
  586.  
  587.     /**
  588.      * Tell the wizard to ignore the value of java.beans.Beans.isDesignTime().
  589.      */
  590.     public void setIgnoreDesignTime(boolean ignore)
  591.     {
  592.         ignoreDesignTime = ignore;
  593.     }
  594.  
  595.     public boolean getIgnoreDesignTime()
  596.     {
  597.         return ignoreDesignTime;
  598.     }
  599.  
  600.     private boolean ignoreDesignTime = false;
  601.  
  602.     // Debug
  603.  
  604.     /*
  605.     private void debug(String s) {
  606.         System.err.println("SimpleWizardController: " + s);
  607.     }
  608.     */
  609. }
  610.