/[cvs]/nfo/php/libs/com.newsblob.phphtmllib/form/FormProcessor.inc
ViewVC logotype

Diff of /nfo/php/libs/com.newsblob.phphtmllib/form/FormProcessor.inc

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.1 by jonen, Sat Feb 22 21:07:42 2003 UTC revision 1.5 by jonen, Thu Aug 11 14:09:26 2005 UTC
# Line 4  Line 4 
4   *   *
5   * $Id$   * $Id$
6   *   *
7   * @author Walter A. Boring IV <waboring@buildabetterweb.com>   * @author Walter A. Boring IV <waboring@newsblob.com>
8   * @author Suren Markossian <suren@cbestwhat?>   * @author Suren Markossian <suren@cbestwhat?>
9   * @package phpHtmlLib   * @package phpHtmlLib
10   * @subpackage FormProcessing   * @subpackage FormProcessing
# Line 13  Line 13 
13   *   *
14   */   */
15    
16  define(FORM_ACTION, "_form_action");  define("FORM_ACTION", "_form_action");
17  define(FORM_VISITED, "_form_visited");  define("FORM_VISITED", "_form_visited");
18  define(FORM_CONFIRM, "_form_confirm");  define("FORM_CONFIRM", "_form_confirm");
19    
20  /**  /**
21   * This is the main engine for the processing   * This is the main engine for the processing
22   * of Forms.  It builds the form tag, and calls   * of Forms.  It builds the form tag, and calls
23   * the appropriate FormContent methods to build   * the appropriate FormContent methods to build
24   * the FormElement's and validation, as well as   * the FormElement's and validation, as well as
25   * backend processing to do the action after the   * backend processing to do the action after the
26   * data has been validated.   * data has been validated.
27   *   *
# Line 30  define(FORM_CONFIRM, "_form_confirm"); Line 30  define(FORM_CONFIRM, "_form_confirm");
30   */   */
31  class FormProcessor extends Container {  class FormProcessor extends Container {
32    
     /**  
      * This holds the name of the form  
      * for js that needs it  
      */  
     var $_form_name="forms[0]";  
   
33    
34      /**      /**
35       * The action for the form tag       * This array holds the FORMtag
36       */       * attributes for this form
     var $_form_action = "";  
   
     /**  
      * The form's enctype attribute.  
      * ie <form enctype="multipart/form_data">  
37       *       *
38       */       */
39      var $_form_enctype = NULL;      var $_form_attributes = array("method" => "post",
40                                      "action" => "",
41                                      "name" => "myform",
42                                      "target" => "",
43                                      "onsubmit" => "",
44                                      "style" => "margin: 0px 0px 0px 0px;");
45    
46      /**      /**
47       * This holds the FormContent Object       * This holds the FormContent Object
# Line 77  class FormProcessor extends Container { Line 71  class FormProcessor extends Container {
71       */       */
72      var $_form_success_render = TRUE;      var $_form_success_render = TRUE;
73    
74        /**
75         * This is the FormValidation object
76         * used to validate the form elements
77         */
78        var $_FormValidation = NULL;
79    
80        /**
81         * The action that was taken
82         * for the form
83         */
84        var $_form_submit_action = NULL;
85    
86        /**
87         * The form was processed and passed
88         * the confirmation if any, and
89         * it was successfull ?
90         */
91        var $_confirmed_successfull = FALSE;
92    
93        /**
94         * This tells us to show or not to
95         * show the form errors autmatically.
96         * The user of the FormProcessor
97         * may want to deal with errors manually
98         */
99        var $_auto_show_errors = TRUE;
100    
101    
102      /**      /**
103       * The constructor for the FormProcessor       * The constructor for the FormProcessor
# Line 84  class FormProcessor extends Container { Line 105  class FormProcessor extends Container {
105       * @param FormContent object       * @param FormContent object
106       * @param string the form name       * @param string the form name
107       */       */
108      function FormProcessor(&$form_content, $form_name="forms[0]",      function FormProcessor(&$form_content, $form_name="myform",
109                             $form_action=NULL) {                             $form_action=NULL) {
110    
         $this->_form_name = $form_name;  
111          $this->_form_content = &$form_content;          $this->_form_content = &$form_content;
112            $this->set_form_name( $form_name );
113          $this->_form_content->set_form_name($form_name);          $this->_form_content->set_form_name($form_name);
114    
115          if ($form_action != NULL) {          if ($form_action != NULL) {
116              $this->_form_action = $form_action;              $this->set_form_action( $form_action );
117          } else {          } else {
118              $this->_form_action = $_SERVER["PHP_SELF"];              $this->set_form_action( $_SERVER["PHP_SELF"] );
119          }          }
120    
121            //Set up the Validation object
122            //and the FormErrors object to
123            //be used by this form.
124            $this->setup_validation();
125    
126          //now process the form          //now process the form
127          $this->_process_form();          $this->_process_form();
128      }      }
129    
130      /**      /**
131         * This function is used to setup
132         * the validation object and the
133         * form errors object that is to be
134         * used by this form.
135         *
136         * You can override this method to
137         * use a different FormErrors object
138         * for localization.
139         */
140        function setup_validation() {
141            $this->_FormValidation =& FormValidation::singleton();
142            $this->_form_content->_set_validation_object($this->_FormValidation);
143        }
144    
145        /**
146       * This method does the logic of       * This method does the logic of
147       * doing the form processing       * doing the form processing
148       */       */
149      function _process_form() {      function _process_form() {
150          //let the form build the FormElement objects          $this->_init_form_content();
         //that will be used by the form  
         $this->_form_content->form_init_elements();  
   
         //first we need to  
         if (!$_POST[FORM_VISITED]) {  
             $this->_form_content->form_init_data();  
         }  
   
151    
152          //we only need to process the form          //we only need to process the form
153          //if it has been visited. Otherwise          //if it has been visited. Otherwise
154          //it just gets rendered.          //it just gets rendered.
155          if ($_POST[FORM_VISITED] == 1) {          if (!empty($_REQUEST[$this->_form_attributes['name'].FORM_VISITED]) &&
156              $this->_form_content->set_action($_POST[FORM_ACTION]);              $_REQUEST[$this->_form_attributes['name'].FORM_VISITED] == 1) {
157                $this->_set_action();
158    
159              //let see if this was a confirmation page.              //let see if this was a confirmation page.
160              if ( $_POST[FORM_CONFIRM] == 1 ) {              if ( !empty($_REQUEST[FORM_CONFIRM]) ) {
161                  //looks like this was a submit on a                  if ($_REQUEST[FORM_CONFIRM] == 1) {
162                  //confirmation page.  we don't need                      //looks like this was a submit on a
163                  //to do form field validation.                      //confirmation page.  we don't need
164                  $this->_confirmed = TRUE;                      //to do form field validation.
165                        $this->_confirmed = TRUE;
166                    } else {
167                        //looks like the confirmation was aborted.
168                        xxx("aborted");
169                    }
170              }              }
171    
172              //now do the validation                          if ($this->_form_content->has_confirm()) {
173              if (!$this->_confirmed) {                      //the form content has a confirmation
174                  //we haven't been confirmed, so we                      //we need to process
175                  //need to validate the form.                      $this->_has_errors = !$this->_pre_confirm();
176                  if ($this->can_validate()) {              }
177                      //looks like we should do validation  
178                      $this->do_validation();              //we haven't been confirmed, so we
179                  }              //need to validate the form.
180                  if (!$this->_has_errors) {              if ($this->can_validate()) {
181                      //no errors were found                  //looks like we should do validation
182                      if ($this->_form_content->has_confirm()) {                  $this->do_validation();
183                          //the form content has a confirmation              }
184                          //we need to process              if (!$this->_has_errors) {
185                          $this->_has_errors = !$this->_pre_confirm();                  //no errors were found
                     } else {  
                         //make sure we don't have any backend errors  
                         $this->_has_errors = !$this->_form_content->form_backend_validation();  
                         if (!$this->_has_errors) {  
                             $this->_has_errors = !$this->_process_action();  
                         }  
                     }  
                 }  
             } else {  
186                  //make sure we don't have any backend errors                  //make sure we don't have any backend errors
187                  $this->_has_errors = !$this->_form_content->form_backend_validation();                  $this->_has_errors = !$this->_form_content->form_backend_validation();
188                  if (!$this->_has_errors) {                  if (!$this->_has_errors && (($this->_form_content->has_confirm()
189                                                 && $this->_confirmed) || !$this->_form_content->has_confirm())) {
190                        // process action only at the final stage
191                      $this->_has_errors = !$this->_process_action();                      $this->_has_errors = !$this->_process_action();
192                  }                  
193                        if (!$this->_has_errors) {
194                            $this->_set_confirmed_success(TRUE);
195                        }
196                    }
197              }              }
198          }          }
199      }      }
# Line 176  class FormProcessor extends Container { Line 212  class FormProcessor extends Container {
212      }      }
213    
214      /**      /**
215       * This method calls the FormContent       * This method calls the FormContent
216       * to let it do any data munging before the       * to let it do any data munging before the
217       * confirmation page is rendered       * confirmation page is rendered
218       */       */
219      function _pre_confirm() {      function _pre_confirm() {
220    
221            if ($this->_form_content->_has_file_element) {
222                //we need to allow any/all of the file elements
223                //save the temp files during a confirmation.
224                //if we don't, then the web server may delete
225                //them before confirmation has been accepted.
226                $this->_form_content->_pre_confirm();
227            }
228    
229            //call the user defineable FormContent pre_confirm.
230          return $this->_form_content->pre_confirm();          return $this->_form_content->pre_confirm();
231      }      }
232    
# Line 193  class FormProcessor extends Container { Line 239  class FormProcessor extends Container {
239      function do_validation() {      function do_validation() {
240          $keys = array_keys( $this->_form_content->_elements );          $keys = array_keys( $this->_form_content->_elements );
241          foreach( $keys as $key ) {          foreach( $keys as $key ) {
242              $valid = $this->_form_content->_elements[$key]->_do_validation();              if (!$this->_form_content->_elements[$key]->is_disabled()) {
243              if (!$valid) {                  $valid = $this->_form_content->_elements[$key]->_do_validation($this->_FormValidation);
244                  $this->_has_errors = TRUE;                  if (!$valid) {
245                        $this->_has_errors = TRUE;
246                    }                              
247                } else {
248                    //detect disabled field hack attempts
249                    if ($this->_form_content->_elements[$key]->has_error()) {
250                        $this->_has_errors = TRUE;
251                    }
252              }              }
253          }          }
254      }      }
# Line 212  class FormProcessor extends Container { Line 265  class FormProcessor extends Container {
265              return $this->render_error($indent_level, $output_debug);              return $this->render_error($indent_level, $output_debug);
266          } else {          } else {
267              //there are no errors!              //there are no errors!
268              if ($_POST[FORM_VISITED] == 1) {              if (@$_REQUEST[$this->_form_attributes['name'] . FORM_VISITED] == 1) {
269                  //looks like the form has been processed?                  //looks like the form has been processed?
270                  if ($this->_form_content->has_confirm() && !$this->_confirmed) {                  if ($this->_form_content->has_confirm() && !$this->_confirmed) {
271                      return $this->render_confirm($indent_level, $output_debug);                      return $this->render_confirm($indent_level, $output_debug);
272                  } else {                  } else {
273                      //Looks like the action worked                      //Looks like the action worked
274                      $success = $this->_form_content->form_success($this->_message);                      $success = $this->_form_content->form_success();
275                        
276                      if ($this->_form_success_render) {                      if ($this->_form_success_render) {
277                          return $this->render_form($indent_level, $output_debug,                          return $this->render_form($indent_level, $output_debug,
278                                                    $success);                                                    $success);
# Line 256  class FormProcessor extends Container { Line 309  class FormProcessor extends Container {
309          //build the $this->_form object.          //build the $this->_form object.
310          $this->_build_form_tag();          $this->_build_form_tag();
311    
312            //check to see if the form_content
313            //has any js, or any of the form elements
314            //have js.
315            $form_js = $this->_build_javascript();
316            if (strlen($form_js) > 0) {
317                $script = html_script();
318                $script->add( $form_js );
319                //$this->_form->add( $script );
320            }
321    
322          if ($obj) {          if ($obj) {
323              $this->_form->add_reference( $obj );              $this->_form->add_reference( $obj );
324          }          }
# Line 269  class FormProcessor extends Container { Line 332  class FormProcessor extends Container {
332          //Ok lets add our hidden vars          //Ok lets add our hidden vars
333          $this->__hidden_fields();          $this->__hidden_fields();
334    
335          return $this->_form->render($indent_level, $output_debug);          if (isset($script)) {
336                $c = container( $script, $this->_form );
337                return $c->render($indent_level, $output_debug);
338            } else {
339                return $this->_form->render($indent_level, $output_debug);
340            }
341    
342      }      }
343    
344      /**      /**
# Line 290  class FormProcessor extends Container { Line 359  class FormProcessor extends Container {
359          $this->_build_form_tag();          $this->_build_form_tag();
360    
361          //add the confirm object/html          //add the confirm object/html
362          $confirm = &$this->_form_content->form_confirm( $this->data );          $confirm = &$this->_form_content->form_confirm( );
363          $this->_form->add_reference( $confirm );          $this->_form->add_reference( $confirm );
364    
365          //ok add all of the submitted data as hidden form fields          //ok add all of the submitted data as hidden form fields
# Line 315  class FormProcessor extends Container { Line 384  class FormProcessor extends Container {
384       * @return raw html       * @return raw html
385       */       */
386      function render_error( $indent_level, $output_debug) {      function render_error( $indent_level, $output_debug) {
         $wrapper_div = new DIVtag;  
387    
388          //Ok first lets build the error table          if ($this->_auto_show_errors) {
389          $errors = &$this->_form_content->form_errors();              //Ok first lets build the error table
390          if ($errors != NULL) $wrapper_div->add( $errors, html_br() );              $wrapper = new DIVtag;
391                $errors = &$this->_form_content->form_errors();
392                if ($errors != NULL) $wrapper->add( $errors, html_br() );
393            } else {
394                $wrapper = NULL;
395            }
396    
397          return $this->render_form( $indent_level, $output_debug, $wrapper_div);  
398            return $this->render_form( $indent_level, $output_debug, $wrapper);
399      }      }
400    
401    
# Line 350  class FormProcessor extends Container { Line 424  class FormProcessor extends Container {
424       * is off       * is off
425       *       *
426       */       */
427      function set_render_form_after_success() {      function set_render_form_after_success($flag=TRUE) {
428          $this->_form_success_render = TRUE;          $this->_form_success_render = $flag;
429        }
430    
431        /**
432         * This is used to test to see if the form action
433         * was processed succesfully.
434         * This is usefull for external entities to determine
435         * if the form was processed, and it was successfull.
436         *
437         * @return boolean
438         */
439        function is_action_successfull() {
440            return $this->_confirmed_successfull;
441        }
442    
443        /**
444         * This flag sets the flag that tells
445         * if we successfully confirmed the form,
446         * and processed the action
447         *
448         * @param boolean
449         */
450        function _set_confirmed_success($flag=TRUE) {
451            $this->_confirmed_successfull = $flag;
452        }
453    
454        /**
455         * This sets the flag that tells this class
456         * to automatically call the form contents
457         * form errors and display it or not
458         *
459         * @param boolean - show errors?
460         */
461        function set_auto_error_display($flag=TRUE) {
462            $this->_auto_show_errors = $flag;
463        }
464    
465        /**
466         * This gets the current value of the flag
467         * that tells us to show form errors automatically
468         * or not.
469         *
470         * @return boolean
471         */
472        function get_auto_error_display() {
473            return $this->_auto_show_errors;
474        }
475    
476    
477        /**
478         * This method allows us to get access to the
479         * errors display object that is generated by
480         * the form content.  This is the display
481         * object that is meant to be rendered directly.
482         * If there are no errors. we will return NULL
483         *
484         * @return object
485         */
486        function &get_error_display_object() {
487            if ($this->_has_errors) {
488                return $this->_form_content->form_errors();
489            } else {
490                return NULL;
491            }
492        }
493    
494    
495        /**
496         * This method returns an array of errors that
497         * happened in the form.
498         *
499         * @return array
500         */
501        function get_error_array() {
502            return $this->_form_content->get_error_array();
503        }
504    
505        /**
506         * This returns the flag that tells us that
507         * the form has errors during processing
508         *
509         * @return boolean
510         */
511        function has_errors() {
512            return $this->_has_errors;
513        }
514    
515    
516    
517    
518        //************************************************//
519        //*       FORMtag Attributes for this class      *//
520        //************************************************//
521    
522        /**
523         * This function is used to set the
524         * form name
525         *
526         * @param string
527         */
528        function set_form_name($name) {
529            $this->_form_attributes["name"] = $name;
530        }
531    
532        /**
533         * This function is used to get
534         * the form name
535         *
536         * @return string
537         */
538        function get_form_name() {
539            return $this->_form_attributes["name"];
540        }
541    
542        /**
543         * This function is used to set the
544         * form target
545         *
546         * @param string
547         */
548        function set_form_target($target) {
549            $this->_form_attributes["target"] = $target;
550        }
551    
552        /**
553         * This function is used to get
554         * the form target
555         *
556         * @return string
557         */
558        function get_form_target() {
559            return $this->_form_attributes["target"];
560        }
561    
562        /**
563         * This function is used to set the
564         * form method
565         *
566         * @param string (POST or GET)
567         */
568        function set_form_method($method) {
569            if ( strcasecmp($method,"GET") !=0 && strcasecmp($method,"POST") !=0 ) {
570                user_error("FormProcessor::set_form_method() - INVALID Form method ".$method);
571            } else {
572                $this->_form_attributes["method"] = $method;
573            }
574        }
575    
576        /**
577         * This function is used to get
578         * the form method
579         *
580         * @return string (POST or GET)
581         */
582        function get_form_method() {
583            return $this->_form_attributes["method"];
584        }
585    
586        /**
587         * Sets the form action
588         *
589         * @param string
590         */
591        function set_form_action($action) {
592            $this->_form_attributes["action"] = $action;
593        }
594    
595        /**
596         * This function is used to get
597         * the form action
598         *
599         * @return string (POST or GET)
600         */
601        function get_form_action() {
602            return $this->_form_attributes["action"];
603        }
604    
605        /**
606         * Sets the form enctype
607         *
608         * @param string
609         */
610        function set_form_enctype($enctype) {
611            $this->_form_attributes["enctype"] = $enctype;
612        }
613    
614        /**
615         * This function is used to get
616         * the form enctype value
617         *
618         * @return string
619         */
620        function get_form_enctype() {
621            return $this->_form_attributes["enctype"];
622        }
623    
624    
625        /**
626         * This is used to set the action
627         * submitted by the user
628         *
629         */
630        function _set_action() {
631            $this->_form_submit_action = $_REQUEST[FORM_ACTION];
632            $this->_form_content->set_action($this->_form_submit_action);
633        }
634    
635        /**
636         * This is used to get the action that was
637         * processed by the form
638         *
639         * @return string
640         */
641        function get_action() {
642            return $this->_form_submit_action;
643        }
644    
645    
646        /**
647         * Set the onsubmit attribute to the form
648         * NOTE: The FormContent child can automatically
649         * set this value depending on the FormElement
650         * children it contains.
651         *
652         * @param string
653         * @return none
654         */
655        function set_onsubmit($js) {
656            $this->_form_attributes["onsubmit"] = $js;
657        }
658    
659        /**
660         * Gets the current value of the form tag's
661         * onsubmit value
662         *
663         * @return string
664         */
665        function get_onsubmit() {
666            return $this->_form_attributes["onsubmit"];
667        }
668    
669        /**
670         * Set a random attribute on the form tag.
671         * You should know what you are doing as this
672         * might invalidate the output html with the
673         * W3C validator.
674         *
675         * @param string the key
676         * @param string the value
677         */
678        function set_form_attribute($key, $value) {
679            $this->_form_attributes[$key] = $value;
680        }
681    
682    
683        //************************************//
684        //*       Some Private methods       *//
685        //************************************//
686    
687        /**
688         * This method initializes the FormContent
689         * during processing.
690         *
691         * @return none
692         */
693        function _init_form_content() {
694            //let the form build the FormElement objects
695            //that will be used by the form
696            $this->_form_content->form_init_elements();
697    
698            //first we need to
699            if (!@$_REQUEST[$this->_form_attributes['name'] . FORM_VISITED]) {
700                $this->_form_content->form_init_data();
701            }
702    
703            //see if the form content has a child of the
704            //FEFile element, so we can automatically
705            //add the enctype to the form tag attribute
706            if ($this->_form_content->_has_file_element) {
707                $this->set_form_enctype("multipart/form-data");
708            }
709      }      }
710    
711    
# Line 362  class FormProcessor extends Container { Line 716  class FormProcessor extends Container {
716       * @return FORMtag object.       * @return FORMtag object.
717       */       */
718      function _build_form_tag() {      function _build_form_tag() {
719          $form_attrs = array("method" => "POST",          //see if we need to add the onsubmit attribute to the form
720                              "action" => $this->_form_action,          //this only needs to happen on the non-confirmation
721                              "name" => $this->_form_name,          //portion of the forms.
722                                                          "style" => "margin: 0px 0px 0px 0px;");          if (!isset($_REQUEST[$this->_form_attributes['name'] . FORM_VISITED])) {
723          if ($this->_enctype != NULL)              if (strlen($this->_form_content->_form_on_submit) > 0) {
724              $form_attrs["enctype"] = $this->_enctype;                  $set = TRUE;
725          if ($this->_target != NULL)                  $this->set_onsubmit( $this->get_onsubmit().$this->_form_content->_form_on_submit.$this->_form_content->_form_action_elements_on_submit );
726              $form_attrs["target"] = $this->_target;              }
727          if ($this->_onsubmit != NULL)          } else {
728              $form_attrs["onSubmit"] = $this->_onsubmit;              //re-rendering the form and it has errors.
729                //we need the onsubmit if they have it.
730                if (isset($_REQUEST[$this->_form_attributes['name'] . FORM_VISITED]) && $this->_has_errors) {
731                    if (strlen($this->_form_content->_form_on_submit) > 0) {
732                        $set = TRUE;
733                        $this->set_onsubmit($this->get_onsubmit().$this->_form_content->_form_on_submit.$this->_form_content->_form_action_elements_on_submit );
734                    }
735                } else if (isset($_REQUEST[FORM_CONFIRM]) && $_REQUEST[FORM_CONFIRM] == 1) {
736                    //form has been confirmed lets add it
737                    //in case we are showing the form again
738                    if (strlen($this->_form_content->_form_on_submit) > 0) {
739                        $set = TRUE;
740                        $this->set_onsubmit( $this->get_onsubmit().$this->_form_content->_form_on_submit.$this->_form_content->_form_action_elements_on_submit );
741                    }
742                } else {
743                    $this->set_onsubmit($this->_form_content->_form_action_elements_on_submit);
744                }
745            }
746    
747            $form_attrs = array();
748            foreach( $this->_form_attributes as $name => $value) {
749                if ($value) {
750                    $form_attrs[$name] = $value;
751                }
752            }
753          $this->_form = new FORMtag( $form_attrs );          $this->_form = new FORMtag( $form_attrs );
754      }      }
755    
# Line 384  class FormProcessor extends Container { Line 761  class FormProcessor extends Container {
761      function _add_confirm_data() {      function _add_confirm_data() {
762          $keys = array_keys( $this->_form_content->_elements );          $keys = array_keys( $this->_form_content->_elements );
763          foreach( $keys as $key ) {          foreach( $keys as $key ) {
764              $element_name = $this->_form_content->_elements[$key]->get_element_name();              //make sure the element isn't disabled.
765              $values = $this->_form_content->_elements[$key]->get_value();              if (!$this->_form_content->_elements[$key]->is_disabled()) {
766              if (is_array($values)) {                  $this->_form->add($this->_form_content->_elements[$key]->get_confirm_element());
                 foreach($values as $value) {  
                     $this->_form->add( form_hidden($element_name, $value) );  
                 }                  
             } else {  
                 $this->_form->add( form_hidden($element_name, $values) );  
   
767              }              }
768          }          }
769    
770          $keys = array_keys( $this->_form_content->_hidden_elements );          $keys = array_keys( $this->_form_content->_hidden_elements );
771          foreach( $keys as $key ) {          foreach( $keys as $key ) {
772              $this->_form->add( $this->_form_content->_hidden_elements[$key]->get_element() );              $this->_form->add( $this->_form_content->_hidden_elements[$key]->get_confirm_element() );
773          }          }
774      }      }
775    
# Line 424  class FormProcessor extends Container { Line 795  class FormProcessor extends Container {
795       */       */
796      function __hidden_fields() {      function __hidden_fields() {
797          $this->_form->add( form_hidden(FORM_ACTION),          $this->_form->add( form_hidden(FORM_ACTION),
798                             form_hidden(FORM_VISITED,1) );                             form_hidden($this->_form_attributes['name'] . FORM_VISITED,1) );
799    
800          if ($this->_form_content->has_confirm() && !$this->_confirmed) {          if ($this->_form_content->has_confirm() && !$this->_confirmed) {
801              if (!$_POST[FORM_VISITED] || $this->_has_errors) {              if (@!$_REQUEST[$this->_form_attributes['name'] . FORM_VISITED] || $this->_has_errors) {
802                  $this->_form->add( form_hidden(FORM_CONFIRM, 0 ) );                  $this->_form->add( form_hidden(FORM_CONFIRM, 0 ) );
803              } else {              } else {
804                  $this->_form->add( form_hidden(FORM_CONFIRM, 1 ) );                  $this->_form->add( form_hidden(FORM_CONFIRM, 1 ) );
# Line 437  class FormProcessor extends Container { Line 808  class FormProcessor extends Container {
808              $this->_form->add( form_hidden(FORM_CONFIRM, 0 ) );              $this->_form->add( form_hidden(FORM_CONFIRM, 0 ) );
809          }          }
810      }      }
811    
812        /**
813         * This method is used to build any Javascript
814         * that is used by the form and/or the form elements
815         * used in the form.
816         *
817         * @return string
818         */
819        function _build_javascript() {
820            $form_js = $this->_form_content->javascript();
821    
822            //now walk each form element and try to get any js
823            foreach( $this->_form_content->_elements as $element ) {
824                $form_js .= $element->javascript();
825            }
826    
827            return $form_js;
828        }
829  }  }
830  ?>  ?>
Legend:
Removed from v.1.1  
changed lines
  Added in v.1.5
MailToCvsAdmin">MailToCvsAdmin
 ViewVC Help
Powered by ViewVC 1.1.26 RSS 2.0 feed