com.newsblob.phphtmllib/form/FormProcessor.inc

<?php
/**
 * This file contains the FormProcessor class.
 *
 * $Id: FormProcessor.inc,v 1.36 2004/03/25 00:44:17 hemna Exp $
 *
 * @author Walter A. Boring IV <waboring@buildabetterweb.com>
 * @author Suren Markossian <suren@cbestwhat?>
 * @package phpHtmlLib
 * @subpackage FormProcessing
 *
 * @copyright LGPL - See LICENCE
 *
 */

define("FORM_ACTION", "_form_action");
define("FORM_VISITED", "_form_visited");
define("FORM_CONFIRM", "_form_confirm");

/**
 * This is the main engine for the processing
 * of Forms.  It builds the form tag, and calls
 * the appropriate FormContent methods to build
 * the FormElement's and validation, as well as 
 * backend processing to do the action after the
 * data has been validated.
 *
 * @package phpHtmlLib
 * @subpackage FormProcessing
 */
class FormProcessor extends Container {


    /**
     * This array holds the FORMtag
     * attributes for this form
     *
     */
    var $_form_attributes = array("method" => "post",
                                  "action" => "",
                                  "name" => "myform",
                                  "target" => "",
                                  "onsubmit" => "",
                                  "style" => "margin: 0px 0px 0px 0px;");

    /**
     * This holds the FormContent Object
     * that knows how to render the
     * form.
     */
    var $_form_content = NULL;


    /**
     * This flag lets us know there
     * were errors during processing or
     * validating the form.
     */
    var $_has_errors = FALSE;

    /**
     * Flag to let us know the form
     * has been confirmed.
     */
    var $_confirmed = FALSE;

    /**
     * Flag to let us know if we should
     * render the form after it was
     * successfully processed
     */
    var $_form_success_render = TRUE;

    /**
     * This is the FormValidation object
     * used to validate the form elements
     */
    var $_FormValidation = NULL;

    /**
     * The action that was taken
     * for the form
     */
    var $_form_submit_action = NULL;

    /**
     * The form was processed and passed
     * the confirmation if any, and 
     * it was successfull ?
     */
    var $_confirmed_successfull = FALSE;

    /**
     * This tells us to show or not to
     * show the form errors autmatically.
     * The user of the FormProcessor
     * may want to deal with errors manually
     */
    var $_auto_show_errors = TRUE;


    /**
     * The constructor for the FormProcessor
     *
     * @param FormContent object
     * @param string the form name
     */
    function FormProcessor(&$form_content, $form_name="myform",
                           $form_action=NULL) {

        $this->_form_content = &$form_content;
        $this->set_form_name( $form_name );
        $this->_form_content->set_form_name($form_name);

        if ($form_action != NULL) {
            $this->set_form_action( $form_action );
        } else {
            $this->set_form_action( $_SERVER["PHP_SELF"] );
        }

        //Set up the Validation object
        //and the FormErrors object to
        //be used by this form.
        $this->setup_validation();

        //now process the form
        $this->_process_form();
    }

    /**
     * This function is used to setup
     * the validation object and the
     * form errors object that is to be
     * used by this form.
     *
     * You can override this method to 
     * use a different FormErrors object
     * for localization.
     */
     function setup_validation() {
         $this->_FormValidation = new FormValidation( new FormErrors );
     }

    /**
     * This method does the logic of
     * doing the form processing
     */
    function _process_form() {
        $this->_init_form_content();

        //we only need to process the form
        //if it has been visited. Otherwise
        //it just gets rendered.
        if (!empty($_REQUEST[FORM_VISITED]) && $_REQUEST[FORM_VISITED] == 1) {
            $this->_set_action();

            //let see if this was a confirmation page.
            if ( !empty($_REQUEST[FORM_CONFIRM]) ) {
                if ($_REQUEST[FORM_CONFIRM] == 1) {
                    //looks like this was a submit on a
                    //confirmation page.  we don't need
                    //to do form field validation.
                    $this->_confirmed = TRUE;
                } else {
                    //looks like the confirmation was aborted.
                    xxx("aborted");
                }
            }

            //now do the validation
            if (!$this->_confirmed) {
                //we haven't been confirmed, so we
                //need to validate the form.
                if ($this->can_validate()) {
                    //looks like we should do validation
                    $this->do_validation();
                }
                if (!$this->_has_errors) {
                    //no errors were found
                    if ($this->_form_content->has_confirm()) {
                        //the form content has a confirmation
                        //we need to process
                        $this->_has_errors = !$this->_pre_confirm();
                    } 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();
                            if (!$this->_has_errors) {
                                $this->_set_confirmed_success(TRUE);
                            }
                        }
                    }
                }
            } 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();
                    if (!$this->_has_errors) {
                        $this->_set_confirmed_success(TRUE);
                    }
                }                
            }
        }
    }


    /**
     * This function is responsible for
     * processing the form action
     * after validation, and form confirmation
     * happens.
     *
     */
    function _process_action() {
        //There were no validation errors.
        return $this->_form_content->form_action();
    }

    /**
     * This method calls the FormContent 
     * to let it do any data munging before the
     * confirmation page is rendered
     */
    function _pre_confirm() {

        if ($this->_form_content->_has_file_element) {
            //we need to allow any/all of the file elements
            //save the temp files during a confirmation.
            //if we don't, then the web server may delete 
            //them before confirmation has been accepted.
            $this->_form_content->_pre_confirm();
        }

        //call the user defineable FormContent pre_confirm.
        return $this->_form_content->pre_confirm();
    }


    /**
     * This method walks the FormContent's visible elements
     * and calls the validation function for the element
     *
     */
    function do_validation() {
        $keys = array_keys( $this->_form_content->_elements );
        foreach( $keys as $key ) {
            $valid = $this->_form_content->_elements[$key]->_do_validation($this->_FormValidation);
            if (!$valid) {
                $this->_has_errors = TRUE;
            }
        }
    }


    /**
     * This method is called to render the form's html
     *
     */
    function render($indent_level=0, $output_debug=0) {
        if ($this->_has_errors) {
            //we need to render the form errors
            //and then the form
            return $this->render_error($indent_level, $output_debug);
        } else {
            //there are no errors!
            if (@$_REQUEST[FORM_VISITED] == 1) {
                //looks like the form has been processed?
                if ($this->_form_content->has_confirm() && !$this->_confirmed) {
                    return $this->render_confirm($indent_level, $output_debug);
                } else {
                    //Looks like the action worked
                    $success = $this->_form_content->form_success();
                    
                    if ($this->_form_success_render) {
                        return $this->render_form($indent_level, $output_debug,
                                                  $success);
                    } else {
                        if (method_exists($success,"render")) {
                            //looks like this is an object.
                            //we'll assume it has a render function.
                            return $success->render($indent_level, $output_debug);
                        } else {
                            //since its not an object,
                            //lets just display it.
                            return $success;
                        }
                    }
                }
            } else {
                return $this->render_form($indent_level, $output_debug);
            }
        }
    }


    /**
     * This renders the form
     *
     * @param the FormContent->form() object
     * @param int - $indent_level
     * @param int - $output_debug
     * @param object - the form errors object.
     * @return raw html
     */
    function render_form( $indent_level, $output_debug, $obj=NULL ) {

        //build the $this->_form object.
        $this->_build_form_tag();

        //check to see if the form_content
        //has any js, or any of the form elements
        //have js.
        $form_js = $this->_build_javascript();
        if (strlen($form_js) > 0) {
            $script = html_script();
            $script->add( $form_js );
            //$this->_form->add( $script );
        }

        if ($obj) {
            $this->_form->add_reference( $obj );
        }

        $this->_form->add_reference( $this->_form_content->form() );

        //add the FormContent's hidden declared
        //hidden form fields.
        $this->_add_hidden_fields();

        //Ok lets add our hidden vars
        $this->__hidden_fields();

        if (isset($script)) {
            $c = container( $script, $this->_form );
            return $c->render($indent_level, $output_debug);
        } else {
            return $this->_form->render($indent_level, $output_debug);
        }
        
    }

    /**
     * This function renders the confirmation
     * page.  This page sits in between the
     * front end form, and the action handler.
     * This only gets called after a form
     * and its data has been successfully
     * validated.
     *
     * @param int - $indent_level
     * @param int - $output_debug
     *
     * @return string - the raw html
     */
    function render_confirm( $indent_level, $output_debug ) {
        //build the $this->_form object.
        $this->_build_form_tag();

        //add the confirm object/html
        $confirm = &$this->_form_content->form_confirm( );
        $this->_form->add_reference( $confirm );

        //ok add all of the submitted data as hidden form fields
        $this->_add_confirm_data();

        //Ok lets add our hidden vars
        $this->__hidden_fields();

        return $this->_form->render($indent_level, $output_debug);
    }


    /**
     * This renders the error table
     * and then the form with the fields
     *
     * @param array - the form field vlues.
     * @param array - array of errors.
     * @param int - $indent_level
     * @param int - $output_debug
     *
     * @return raw html
     */
    function render_error( $indent_level, $output_debug) {
        
        if ($this->_auto_show_errors) {
            //Ok first lets build the error table
            $wrapper = new DIVtag;
            $errors = &$this->_form_content->form_errors();
            if ($errors != NULL) $wrapper->add( $errors, html_br() );
        } else {
            $wrapper = NULL;
        }
        

        return $this->render_form( $indent_level, $output_debug, $wrapper);
    }


    //***********************************************//
    //*       utility functions for this class      *//
    //***********************************************//


    /**
     * This method lets us turn on/off the
     * ability to do validation for the form
     *
     * @return BOOLEAN
     */
    function can_validate() {
        return TRUE;
    }


    /**
     * This function turns on the ability to
     * render the form after the success
     * of the action.  Normally this feature
     * is off
     *
     */
    function set_render_form_after_success($flag=TRUE) {
        $this->_form_success_render = $flag;
    }

    /**
     * This is used to test to see if the form action
     * was processed succesfully. 
     * This is usefull for external entities to determine
     * if the form was processed, and it was successfull.
     *
     * @return boolean
     */
    function is_action_successfull() {
        return $this->_confirmed_successfull;
    }

    /**
     * This flag sets the flag that tells
     * if we successfully confirmed the form,
     * and processed the action
     *
     * @param boolean
     */
    function _set_confirmed_success($flag=TRUE) {
        $this->_confirmed_successfull = $flag;
    }

    /**
     * This sets the flag that tells this class
     * to automatically call the form contents
     * form errors and display it or not
     * 
     * @param boolean - show errors?
     */
    function set_auto_error_display($flag=TRUE) {
        $this->_auto_show_errors = $flag;
    }

    /**
     * This gets the current value of the flag
     * that tells us to show form errors automatically
     * or not.
     *
     * @return boolean
     */
    function get_auto_error_display() {
        return $this->_auto_show_errors;
    }


    /**
     * This method allows us to get access to the
     * errors display object that is generated by
     * the form content.  This is the display
     * object that is meant to be rendered directly.
     * If there are no errors. we will return NULL
     *
     * @return object
     */
    function &get_error_display_object() {
        if ($this->_has_errors) {
            return $this->_form_content->form_errors();
        } else {
            return NULL;
        }
    }


    /**
     * This method returns an array of errors that
     * happened in the form.
     * 
     * @return array
     */
    function get_error_array() {
        return $this->_form_content->get_error_array();
    }

    /**
     * This returns the flag that tells us that
     * the form has errors during processing
     *
     * @return boolean
     */
    function has_errors() {
        return $this->_has_errors;
    }


    //************************************************//
    //*       FORMtag Attributes for this class      *//
    //************************************************//

    /**
     * This function is used to set the
     * form name
     *
     * @param string
     */
    function set_form_name($name) {
        $this->_form_attributes["name"] = $name;
    }

    /**
     * This function is used to get
     * the form name
     *
     * @return string
     */
    function get_form_name() {
        return $this->_form_attributes["name"];
    }

    /**
     * This function is used to set the
     * form target
     *
     * @param string
     */
    function set_form_target($target) {
        $this->_form_attributes["target"] = $target;
    }

    /**
     * This function is used to get
     * the form target
     *
     * @return string
     */
    function get_form_target() {
        return $this->_form_attributes["target"];
    }

    /**
     * This function is used to set the
     * form method
     *
     * @param string (POST or GET)
     */
    function set_form_method($method) {
        if ( strcasecmp($method,"GET") !=0 && strcasecmp($method,"POST") !=0 ) {
            user_error("FormProcessor::set_form_method() - INVALID Form method ".$method);
        } else {
            $this->_form_attributes["method"] = $method;
        }
    }

    /**
     * This function is used to get
     * the form method
     *
     * @return string (POST or GET)
     */
    function get_form_method() {
        return $this->_form_attributes["method"];
    }

    /**
     * Sets the form action
     *
     * @param string
     */
    function set_form_action($action) {
        $this->_form_attributes["action"] = $action;
    }

    /**
     * This function is used to get
     * the form action
     *
     * @return string (POST or GET)
     */
    function get_form_action() {
        return $this->_form_attributes["action"];
    }

    /**
     * Sets the form enctype
     *
     * @param string
     */
    function set_form_enctype($enctype) {
        $this->_form_attributes["enctype"] = $enctype;
    }

    /**
     * This function is used to get
     * the form enctype value
     *
     * @return string
     */
    function get_form_enctype() {
        return $this->_form_attributes["enctype"];
    }


    /**
     * This is used to set the action 
     * submitted by the user
     *
     */
    function _set_action() {
        $this->_form_submit_action = $_REQUEST[FORM_ACTION];
        $this->_form_content->set_action($this->_form_submit_action);
    }

    /**
     * This is used to get the action that was
     * processed by the form
     *
     * @return string
     */
    function get_action() {
        return $this->_form_submit_action;
    }


    /**
     * Set the onsubmit attribute to the form
     * NOTE: The FormContent child can automatically
     * set this value depending on the FormElement
     * children it contains.
     * 
     * @param string
     * @return none
     */
    function set_onsubmit($js) {
        $this->_form_attributes["onsubmit"] = $js;
    }

    /**
     * Gets the current value of the form tag's
     * onsubmit value
     * 
     * @return string
     */
    function get_onsubmit() {
        return $this->_form_attributes["onsubmit"];
    }


    //************************************//
    //*       Some Private methods       *//
    //************************************//

    /**
     * This method initializes the FormContent
     * during processing.
     * 
     * @return none
     */
    function _init_form_content() {
        //let the form build the FormElement objects
        //that will be used by the form
        $this->_form_content->form_init_elements();

        //first we need to
        if (!@$_REQUEST[FORM_VISITED]) {
            $this->_form_content->form_init_data();
        }

        //see if the form content has a child of the
        //FEFile element, so we can automatically
        //add the enctype to the form tag attribute
        if ($this->_form_content->_has_file_element) {
            $this->set_form_enctype("multipart/form-data");
        }       
    }


    /**
     * this function builds the FORMtag object
     * and its attributes.
     *
     * @return FORMtag object.
     */
    function _build_form_tag() {
        //see if we need to add the onsubmit attribute to the form
        //this only needs to happen on the non-confirmation
        //portion of the forms.
        if (!isset($_REQUEST[FORM_VISITED])) {
            if (strlen($this->_form_content->_form_on_submit) > 0) {
                $set = TRUE;
                $this->set_onsubmit( $this->get_onsubmit().$this->_form_content->_form_on_submit );
            }
        } else {
            //re-rendering the form and it has errors.
            //we need the onsubmit if they have it.
            if ($_REQUEST[FORM_VISITED] && $this->_has_errors) {
                if (strlen($this->_form_content->_form_on_submit) > 0) {
                    $set = TRUE;
                    $this->set_onsubmit( $this->get_onsubmit().$this->_form_content->_form_on_submit );
                }
            }

            //form has been confirmed lets add it
            //in case we are showing the form again
            if (isset($_REQUEST[FORM_CONFIRM]) && $_REQUEST[FORM_CONFIRM] == 1) {
                if (strlen($this->_form_content->_form_on_submit) > 0) {
                    $set = TRUE;
                    $this->set_onsubmit( $this->get_onsubmit().$this->_form_content->_form_on_submit );
                }
            }
        }

        $form_attrs = array();
        foreach( $this->_form_attributes as $name => $value) {
            if ($value) {
                $form_attrs[$name] = $value;
            }
        }       
        $this->_form = new FORMtag( $form_attrs );
    }

    /**
     * This adds all of the submitted data as
     * hidden form fields
     *
     */
    function _add_confirm_data() {
        $keys = array_keys( $this->_form_content->_elements );
        foreach( $keys as $key ) {
            $this->_form->add($this->_form_content->_elements[$key]->get_confirm_element());
        }

        $keys = array_keys( $this->_form_content->_hidden_elements );
        foreach( $keys as $key ) {
            $this->_form->add( $this->_form_content->_hidden_elements[$key]->get_confirm_element() );
        }
    }


    /**
     * This function adds the form content's
     * hidden form fields to the
     * form automatically
     *
     */
    function _add_hidden_fields() {
        //Lets add the form's hidden vars it wants
        foreach ($this->_form_content->_hidden_elements as $element) {
            $this->_form->add( $element->get_element() );
        }
    }


    /**
     * This method adds the processor specific
     * hidden fields.
     *
     */
    function __hidden_fields() {
        $this->_form->add( form_hidden(FORM_ACTION),
                           form_hidden(FORM_VISITED,1) );

        if ($this->_form_content->has_confirm() && !$this->_confirmed) {
            if (@!$_REQUEST[FORM_VISITED] || $this->_has_errors) {
                $this->_form->add( form_hidden(FORM_CONFIRM, 0 ) );
            } else {
                $this->_form->add( form_hidden(FORM_CONFIRM, 1 ) );
            }
        } else if ($this->_form_content->has_confirm() && !$this->_confirmed) {
            //reset this so they can submit again
            $this->_form->add( form_hidden(FORM_CONFIRM, 0 ) );
        }
    }

    /**
     * This method is used to build any Javascript
     * that is used by the form and/or the form elements
     * used in the form.
     *
     * @return string
     */
    function _build_javascript() {
        $form_js = $this->_form_content->javascript();

        //now walk each form element and try to get any js
        foreach( $this->_form_content->_elements as $element ) {
            $form_js .= $element->javascript();
        }

        return $form_js;
    }
}
?>
1	<?php
2	/**
3	* This file contains the FormProcessor class.
4	*
5	* $Id: FormProcessor.inc,v 1.36 2004/03/25 00:44:17 hemna Exp $
6	*
7	* @author Walter A. Boring IV <waboring@buildabetterweb.com>
8	* @author Suren Markossian <suren@cbestwhat?>
9	* @package phpHtmlLib
10	* @subpackage FormProcessing
11	*
12	* @copyright LGPL - See LICENCE
13	*
14	*/
15
16	define("FORM_ACTION", "_form_action");
17	define("FORM_VISITED", "_form_visited");
18	define("FORM_CONFIRM", "_form_confirm");
19
20	/**
21	* This is the main engine for the processing
22	* of Forms. It builds the form tag, and calls
23	* the appropriate FormContent methods to build
24	* the FormElement's and validation, as well as
25	* backend processing to do the action after the
26	* data has been validated.
27	*
28	* @package phpHtmlLib
29	* @subpackage FormProcessing
30	*/
31	class FormProcessor extends Container {
32
33
34	/**
35	* This array holds the FORMtag
36	* attributes for this form
37	*
38	*/
39	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
48	* that knows how to render the
49	* form.
50	*/
51	var $_form_content = NULL;
52
53
54	/**
55	* This flag lets us know there
56	* were errors during processing or
57	* validating the form.
58	*/
59	var $_has_errors = FALSE;
60
61	/**
62	* Flag to let us know the form
63	* has been confirmed.
64	*/
65	var $_confirmed = FALSE;
66
67	/**
68	* Flag to let us know if we should
69	* render the form after it was
70	* successfully processed
71	*/
72	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
104	*
105	* @param FormContent object
106	* @param string the form name
107	*/
108	function FormProcessor(&$form_content, $form_name="myform",
109	$form_action=NULL) {
110
111	$this->_form_content = &$form_content;
112	$this->set_form_name( $form_name );
113	$this->_form_content->set_form_name($form_name);
114
115	if ($form_action != NULL) {
116	$this->set_form_action( $form_action );
117	} else {
118	$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
127	$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 = new FormValidation( new FormErrors );
142	}
143
144	/**
145	* This method does the logic of
146	* doing the form processing
147	*/
148	function _process_form() {
149	$this->_init_form_content();
150
151	//we only need to process the form
152	//if it has been visited. Otherwise
153	//it just gets rendered.
154	if (!empty($_REQUEST[FORM_VISITED]) && $_REQUEST[FORM_VISITED] == 1) {
155	$this->_set_action();
156
157	//let see if this was a confirmation page.
158	if ( !empty($_REQUEST[FORM_CONFIRM]) ) {
159	if ($_REQUEST[FORM_CONFIRM] == 1) {
160	//looks like this was a submit on a
161	//confirmation page. we don't need
162	//to do form field validation.
163	$this->_confirmed = TRUE;
164	} else {
165	//looks like the confirmation was aborted.
166	xxx("aborted");
167	}
168	}
169
170	//now do the validation
171	if (!$this->_confirmed) {
172	//we haven't been confirmed, so we
173	//need to validate the form.
174	if ($this->can_validate()) {
175	//looks like we should do validation
176	$this->do_validation();
177	}
178	if (!$this->_has_errors) {
179	//no errors were found
180	if ($this->_form_content->has_confirm()) {
181	//the form content has a confirmation
182	//we need to process
183	$this->_has_errors = !$this->_pre_confirm();
184	} else {
185	//make sure we don't have any backend errors
186	$this->_has_errors = !$this->_form_content->form_backend_validation();
187	if (!$this->_has_errors) {
188	$this->_has_errors = !$this->_process_action();
189	if (!$this->_has_errors) {
190	$this->_set_confirmed_success(TRUE);
191	}
192	}
193	}
194	}
195	} else {
196	//make sure we don't have any backend errors
197	$this->_has_errors = !$this->_form_content->form_backend_validation();
198	if (!$this->_has_errors) {
199	$this->_has_errors = !$this->_process_action();
200	if (!$this->_has_errors) {
201	$this->_set_confirmed_success(TRUE);
202	}
203	}
204	}
205	}
206	}
207
208
209	/**
210	* This function is responsible for
211	* processing the form action
212	* after validation, and form confirmation
213	* happens.
214	*
215	*/
216	function _process_action() {
217	//There were no validation errors.
218	return $this->_form_content->form_action();
219	}
220
221	/**
222	* This method calls the FormContent
223	* to let it do any data munging before the
224	* confirmation page is rendered
225	*/
226	function _pre_confirm() {
227
228	if ($this->_form_content->_has_file_element) {
229	//we need to allow any/all of the file elements
230	//save the temp files during a confirmation.
231	//if we don't, then the web server may delete
232	//them before confirmation has been accepted.
233	$this->_form_content->_pre_confirm();
234	}
235
236	//call the user defineable FormContent pre_confirm.
237	return $this->_form_content->pre_confirm();
238	}
239
240
241	/**
242	* This method walks the FormContent's visible elements
243	* and calls the validation function for the element
244	*
245	*/
246	function do_validation() {
247	$keys = array_keys( $this->_form_content->_elements );
248	foreach( $keys as $key ) {
249	$valid = $this->_form_content->_elements[$key]->_do_validation($this->_FormValidation);
250	if (!$valid) {
251	$this->_has_errors = TRUE;
252	}
253	}
254	}
255
256
257	/**
258	* This method is called to render the form's html
259	*
260	*/
261	function render($indent_level=0, $output_debug=0) {
262	if ($this->_has_errors) {
263	//we need to render the form errors
264	//and then the form
265	return $this->render_error($indent_level, $output_debug);
266	} else {
267	//there are no errors!
268	if (@$_REQUEST[FORM_VISITED] == 1) {
269	//looks like the form has been processed?
270	if ($this->_form_content->has_confirm() && !$this->_confirmed) {
271	return $this->render_confirm($indent_level, $output_debug);
272	} else {
273	//Looks like the action worked
274	$success = $this->_form_content->form_success();
275
276	if ($this->_form_success_render) {
277	return $this->render_form($indent_level, $output_debug,
278	$success);
279	} else {
280	if (method_exists($success,"render")) {
281	//looks like this is an object.
282	//we'll assume it has a render function.
283	return $success->render($indent_level, $output_debug);
284	} else {
285	//since its not an object,
286	//lets just display it.
287	return $success;
288	}
289	}
290	}
291	} else {
292	return $this->render_form($indent_level, $output_debug);
293	}
294	}
295	}
296
297
298	/**
299	* This renders the form
300	*
301	* @param the FormContent->form() object
302	* @param int - $indent_level
303	* @param int - $output_debug
304	* @param object - the form errors object.
305	* @return raw html
306	*/
307	function render_form( $indent_level, $output_debug, $obj=NULL ) {
308
309	//build the $this->_form object.
310	$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) {
323	$this->_form->add_reference( $obj );
324	}
325
326	$this->_form->add_reference( $this->_form_content->form() );
327
328	//add the FormContent's hidden declared
329	//hidden form fields.
330	$this->_add_hidden_fields();
331
332	//Ok lets add our hidden vars
333	$this->__hidden_fields();
334
335	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	/**
345	* This function renders the confirmation
346	* page. This page sits in between the
347	* front end form, and the action handler.
348	* This only gets called after a form
349	* and its data has been successfully
350	* validated.
351	*
352	* @param int - $indent_level
353	* @param int - $output_debug
354	*
355	* @return string - the raw html
356	*/
357	function render_confirm( $indent_level, $output_debug ) {
358	//build the $this->_form object.
359	$this->_build_form_tag();
360
361	//add the confirm object/html
362	$confirm = &$this->_form_content->form_confirm( );
363	$this->_form->add_reference( $confirm );
364
365	//ok add all of the submitted data as hidden form fields
366	$this->_add_confirm_data();
367
368	//Ok lets add our hidden vars
369	$this->__hidden_fields();
370
371	return $this->_form->render($indent_level, $output_debug);
372	}
373
374
375	/**
376	* This renders the error table
377	* and then the form with the fields
378	*
379	* @param array - the form field vlues.
380	* @param array - array of errors.
381	* @param int - $indent_level
382	* @param int - $output_debug
383	*
384	* @return raw html
385	*/
386	function render_error( $indent_level, $output_debug) {
387
388	if ($this->_auto_show_errors) {
389	//Ok first lets build the error table
390	$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
398	return $this->render_form( $indent_level, $output_debug, $wrapper);
399	}
400
401
402
403
404	//***********************************************//
405	//* utility functions for this class *//
406	//***********************************************//
407
408
409	/**
410	* This method lets us turn on/off the
411	* ability to do validation for the form
412	*
413	* @return BOOLEAN
414	*/
415	function can_validate() {
416	return TRUE;
417	}
418
419
420	/**
421	* This function turns on the ability to
422	* render the form after the success
423	* of the action. Normally this feature
424	* is off
425	*
426	*/
427	function set_render_form_after_success($flag=TRUE) {
428	$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	//************************************//
671	//* Some Private methods *//
672	//************************************//
673
674	/**
675	* This method initializes the FormContent
676	* during processing.
677	*
678	* @return none
679	*/
680	function _init_form_content() {
681	//let the form build the FormElement objects
682	//that will be used by the form
683	$this->_form_content->form_init_elements();
684
685	//first we need to
686	if (!@$_REQUEST[FORM_VISITED]) {
687	$this->_form_content->form_init_data();
688	}
689
690	//see if the form content has a child of the
691	//FEFile element, so we can automatically
692	//add the enctype to the form tag attribute
693	if ($this->_form_content->_has_file_element) {
694	$this->set_form_enctype("multipart/form-data");
695	}
696	}
697
698
699	/**
700	* this function builds the FORMtag object
701	* and its attributes.
702	*
703	* @return FORMtag object.
704	*/
705	function _build_form_tag() {
706	//see if we need to add the onsubmit attribute to the form
707	//this only needs to happen on the non-confirmation
708	//portion of the forms.
709	if (!isset($_REQUEST[FORM_VISITED])) {
710	if (strlen($this->_form_content->_form_on_submit) > 0) {
711	$set = TRUE;
712	$this->set_onsubmit( $this->get_onsubmit().$this->_form_content->_form_on_submit );
713	}
714	} else {
715	//re-rendering the form and it has errors.
716	//we need the onsubmit if they have it.
717	if ($_REQUEST[FORM_VISITED] && $this->_has_errors) {
718	if (strlen($this->_form_content->_form_on_submit) > 0) {
719	$set = TRUE;
720	$this->set_onsubmit( $this->get_onsubmit().$this->_form_content->_form_on_submit );
721	}
722	}
723
724	//form has been confirmed lets add it
725	//in case we are showing the form again
726	if (isset($_REQUEST[FORM_CONFIRM]) && $_REQUEST[FORM_CONFIRM] == 1) {
727	if (strlen($this->_form_content->_form_on_submit) > 0) {
728	$set = TRUE;
729	$this->set_onsubmit( $this->get_onsubmit().$this->_form_content->_form_on_submit );
730	}
731	}
732	}
733
734	$form_attrs = array();
735	foreach( $this->_form_attributes as $name => $value) {
736	if ($value) {
737	$form_attrs[$name] = $value;
738	}
739	}
740	$this->_form = new FORMtag( $form_attrs );
741	}
742
743	/**
744	* This adds all of the submitted data as
745	* hidden form fields
746	*
747	*/
748	function _add_confirm_data() {
749	$keys = array_keys( $this->_form_content->_elements );
750	foreach( $keys as $key ) {
751	$this->_form->add($this->_form_content->_elements[$key]->get_confirm_element());
752	}
753
754	$keys = array_keys( $this->_form_content->_hidden_elements );
755	foreach( $keys as $key ) {
756	$this->_form->add( $this->_form_content->_hidden_elements[$key]->get_confirm_element() );
757	}
758	}
759
760
761	/**
762	* This function adds the form content's
763	* hidden form fields to the
764	* form automatically
765	*
766	*/
767	function _add_hidden_fields() {
768	//Lets add the form's hidden vars it wants
769	foreach ($this->_form_content->_hidden_elements as $element) {
770	$this->_form->add( $element->get_element() );
771	}
772	}
773
774
775	/**
776	* This method adds the processor specific
777	* hidden fields.
778	*
779	*/
780	function __hidden_fields() {
781	$this->_form->add( form_hidden(FORM_ACTION),
782	form_hidden(FORM_VISITED,1) );
783
784	if ($this->_form_content->has_confirm() && !$this->_confirmed) {
785	if (@!$_REQUEST[FORM_VISITED] \|\| $this->_has_errors) {
786	$this->_form->add( form_hidden(FORM_CONFIRM, 0 ) );
787	} else {
788	$this->_form->add( form_hidden(FORM_CONFIRM, 1 ) );
789	}
790	} else if ($this->_form_content->has_confirm() && !$this->_confirmed) {
791	//reset this so they can submit again
792	$this->_form->add( form_hidden(FORM_CONFIRM, 0 ) );
793	}
794	}
795
796	/**
797	* This method is used to build any Javascript
798	* that is used by the form and/or the form elements
799	* used in the form.
800	*
801	* @return string
802	*/
803	function _build_javascript() {
804	$form_js = $this->_form_content->javascript();
805
806	//now walk each form element and try to get any js
807	foreach( $this->_form_content->_elements as $element ) {
808	$form_js .= $element->javascript();
809	}
810
811	return $form_js;
812	}
813	}
814	?>
MailToCvsAdmin">MailToCvsAdmin	ViewVC Help
Powered by ViewVC 1.1.26