com.newsblob.phphtmllib/form/FormElement.inc

<?php
/**
 * This file contains the base FormElement class.
 *
 * $Id: FormElement.inc,v 1.39 2004/03/25 21:02:57 hemna Exp $
 *
 * @author Walter A. Boring IV <waboring@buildabetterweb.com>
 * @author Suren Markosyan <suren@bcsweb.com>
 * @package phpHtmlLib
 * @subpackage FormProcessing
 *
 * @copyright LGPL - See LICENCE
 *
 */

/**
 * This is the base FormElement object.  It can be
 * single form field such as a text input field,
 * or a complex object.
 *
 * Usefull Functions
 *
 * get_value() - This gets the current
 *   'value' of the FormElement.
 *   NOTE: This can be a 'complex' FormElement
 *         in which it may return an array of
 *         values.
 *
 * set_value() - Set the current value
 *   for this FormElement.
 *
 * get_label() - returns the label for this
 *   FormElement.
 *
 *
 * @package phpHtmlLib
 * @subpackage FormProcessing
 */
class FormElement {

    /**
     * Holds the elements label text
     *
     */
    var $_label_text = NULL;

    /**
     * Holds the elements initial value
     *
     */
    var $_value = NULL;

    /**
     * Indicates whether this elements
     * final value is required and cannot
     * be empty
     */
    var $_is_required = TRUE;

    /**
     * holds the array of errors
     * for this element.
     */
    var $_errors = array();

    /**
     * Holds the error message text
     * for validation errors, if any
     *
     */
    var $_error_message = NULL;

    /**
     * Holds the state of the last validation
     * Sets to true in case of a validation error
     *
     */
    var $_has_error = FALSE;

    /**
     * Holds the name of the element
     * as it appears in the form html tag
     *
     */
    var $_element_name = NULL;

    /**
     * Holds additional attributes for
     * the elements html tag
     *
     */
    var $_attributes;

    /**
     * Holds additional style attributes for
     * the elements html tag
     *
     */
    var $_style_attributes;

    /**
     * Indicates a disabled element
     *
     */
    var $_is_disabled = FALSE;

    /**
     * automatically strip slashes from
     * form values?
     */
    var $_stripslashes = FALSE;


    /**
     * This holds the name of the form
     * for js that needs it
     */
    var $_form_name;

    /**
     * This Form Element needs to
     * propogate some js to the
     * Form tag's onsubmit attribute
     *
     * @var string
     */
    var $_has_form_on_submit = false;

    /**
     * This holds an array of FormElement objects 
     * that are slaves of this element
     */
    var $_slave_elements;

    /**
     * The required field string
     * 
     */
    var $_required_field_marker = "*";


    /**
     * The constructor
     *
     * @param label string - text label for the element
     * @param bool required - is this a required element
     */
    function FormElement($label, $required = TRUE) {

        $this->set_label_text($label);
        $this->set_required($required);

        // create a unique name to be used in the html form
        $this->create_element_name();

        //This sets the initial value of the element
        $this->set_value( $this->get_init_value() );
    }

    /**
     * This function will return the
     * slaves of this element
     *
     * @return array of slave elements
     */
    function &get_slave_elements() {
        return $this->_slave_elements;
    }
    
    /**
     * This function will set the
     * slaves of this element
     *
     * @param array of slave elements (element references &)
     */
    function set_slave_elements($slaveElements) {
        $this->_slave_elements = $slaveElements;
        $this->set_data_all_slaves( $this->get_value() );
    }

    
    /**
     * This function will set the
     * data the parent wants to set for the slave
     *
     * @param the slave
     * @param the value being set for the parent
     */
    function set_slave_data(&$slave, $parentValue) {
        ; //override to set the data for the slave
    }

    /**
     * This function will return the
     * elements label text
     *
     * @return string
     */
    function get_label_text() {
        return $this->_label_text;
    }

    /**
     * This function will set the
     * label for the element
     *
     * @param label string
     */
    function set_label_text($label) {
        $this->_label_text = $label;
    }

    /**
     * This function will return the
     * elements value
     *
     * @return mixed
     */
    function get_value() {
        if ($this->_stripslashes) {
            return stripslashes($this->_value);
        } else {
            return $this->_value;
        }
    }


    /**
     * This function will set the
     * initial value for the element
     *
     * @param value mixed
     */
    function set_value($value) {
        $this->_value = $value;
        $this->set_data_all_slaves($value);
    }
    
    /**
     * This function will call set_slave_data for all slaves
     * should be called when value of parent changes
     * 
     * @param string - the current value of parent
     */
    function set_data_all_slaves($parentValue){
        $slaves = &$this->get_slave_elements();
        $num_slaves = count($slaves);
        if ($num_slaves) {
            for($i=0; $i < $num_slaves; $i++){
                $this->set_slave_data($slaves[$i], $parentValue);
            }

        }
    }

    /**
     * in case anyone in JS land
     * needs the name of the form that
     * this element lives in
     *
     * @param string - the form name
     */
    function set_form_name($name) {
        $this->_form_name = $name;
    }

    /**
     * This provides a method
     * for the FormContent
     * to get access to the
     * text associated with a
     * field.  This is only available
     * on FormElements that have text
     * associated with a field.
     * It is used during Confirmation
     *
     * @param mixed the value to look up
     * @return string - the text associated
     */
    function get_value_text() {
        return $this->get_value();
    }


    /**
     * This function set the elements
     * required state
     *
     * @param bool required
     */
    function set_required($required) {
        $this->_is_required = $required;
    }

    /**
     * Returns whether this elements
     * final value cannot be empty
     *
     * @return bool requried
     */
    function is_required() {
        return $this->_is_required;
    }


    /**
     * This returns the initial value of
     * the element
     *
     * @return mixed
     */
    function get_init_value() {
        return @$_REQUEST[str_replace("[]","",$this->get_element_name())];
    }


    /**
     * Sets the disabled element flag
     *
     * @param bool disabled
     */
    function set_disabled($flag) {
        $this->_is_disabled = $flag;
    }

    /**
     * Returns the elements disabled
     * state
     *
     * @return bool disabled
     */
    function is_disabled() {
        return $this->_is_disabled;
    }

        /**
         * This sets the stripslashes flag for
         * this object.
         *
         * @param boolean
         */
        function set_stripslashes( $flag = TRUE ) {
                $this->_stripslashes = $flag;
        }


    /********* Tag attributes methods *********/


    /**
     * add a single attribute (name="value")
     *
     * @param   string  $name   attribute name
     * @param   mixed   $value  the value
     *
     */
    function set_attribute($name, $value = NULL) {
        if ($value == NULL) {
            $this->_attributes[] = $name;
        }
        else {
            $this->_attributes[$name] = $value;
        }
    }

    /**
     * return a single attribute
     *
     * @param   string  $name   attribute name
     * @return  mixed   $value  the value
     *
     */
    function get_attribute($name) {
        return $this->_attributes[$name];
    }

    /**
     * Sets elements title text
     *
     * @param string title
     */
    function set_title($title) {
        $this->set_attribute("title", $title);
    }

    /**
     * Sets elements css attribute
     *
     * @param   string  $name   attribute name
     * @param   mixed   $value  the value
     */
    function set_style_attribute($name, $value) {
        $this->_style_attributes[$name] = $value;
    }

    /**
     * Sets the element's tab index
     *
     * @param int the # for the tabindex
     */
    function set_tabindex($index) {
        $this->set_attribute('tabindex', $index);
    }

    /**
     * Gets the current tab index if any
     *
     * @return int returns 0 if there is none set.
     */
    function get_tabindex() {
        if (isset($this->_attributes['tabindex'])) {
            return $this->_attributes['tabindex'];
        } else {
            return 0;
        }
    }


    /********* Error handling methods *********/

    /**
     * Defines error message text and
     * sets the error flag to true
     *
     * @param mesage text - error message
     * @param label text - a label to provide
     *                     for the error.  This is
     *                     only needed for a complex
     *                     element that has multiple
     *                     'hidden/magic' fields.
     */
    function set_error_message($message, $label=NULL) {
        if ($label == NULL) {
            $label = $this->get_label_text();
        }
        $this->_errors[] = array("label" => $label,
                                 "message" => $message);
        $this->_has_error = TRUE;
    }

    /**
     * This returns the array of errors
     * for this element
     *
     * @param array of errors
     */
    function get_errors() {
        return $this->_errors;
    }


    /**
     * Returns the current error message
     * if any
     *
     * @return mesage text - error message
     */
    function get_error_message() {
        return $this->_error_message;
    }

    /**
     * Returns the current error state
     *
     *
     * @return bool error state
     */
    function has_error($label=NULL) {
        if ($label==NULL) {
            return $this->_has_error;
        } else {
            //they are looking for a specific error
            foreach( $this->_errors as $error) {

                if ($error['label'] == $label) {
                    return TRUE;
                }
            }
            return FALSE;
        }
    }


    /********* Element name handling methods *********/

    /**
     * This function creates element name
     * used in the form based on the text label
     * or any other parameters
     *
     */
    function create_element_name() {

        $name = strtolower($this->get_label_text());
        $len = strlen($name);

        for ($i=0; $i<$len;$i++) {
            if ((ord($name[$i])<97 || ord($name[$i])>122) && (ord($name[$i])<48 || ord($name[$i])>57))
                $name[$i] = "_";
        }

        $this->set_element_name($name);
    }

    /**
     * This allows you to force the element
     * name to whatever you like, so you
     * don't have to use the default name, which is
     * generated based on the label.
     *
     * @param string the form element's name
     * @return none
     */
    function set_element_name($name) {
        $this->_element_name = $name;
    }

    /**
     * Returns the element name
     * to be used in the form
     *
     * @return string form element name
     */
    function get_element_name() {
        return $this->_element_name;
    }


    /********* Validation methods *********/


    /**
     * This function performs the actual validation
     * It is called only if the validation is required by
     * this element
     *
     * This function is responsible for performing complete
     * validation and setting the appropriate error message
     * in case of a failed validation
     *
     * @param FormValidation object.
     */
    function validate(&$_FormValidation) {
        return TRUE;
    }


    /**
     * This function checks if the validation
     * is nesseccary and calls the validate method
     *
     * @param FormValidation object.
     */
    function _do_validation(&$_FormValidation) {
        $value = $this->get_value();
        $has_value = FALSE;
        if (is_array($value)) {
            foreach($value as $entry) {
                if ($entry != NULL) {
                    $has_value = TRUE;
                }
            }
        } else {
            if ($value != NULL) {
                $has_value = TRUE;
            }
        }

        if ($has_value && !$this->is_disabled()) {
            return $this->validate($_FormValidation);
        } else if ($this->is_required()) {
            $this->set_error_message("This field cannot be empty");
            return FALSE;
        } else {
            return TRUE;
        }
    }


    /********* JavaScript event methods *********/


    /**
     * This method is used for adding any javascript
     * that is used by this element.  This will automatically
     * get called and added to the page by the FormProcessor
     *
     * @return string - raw js
     */
    function javascript() {
        return NULL;
    }

    /**
     * This function return the javaScript code for
     * an onClick event
     *
     * @return string - javascript code
     */
    function onClick() {
        return NULL;
    }

    /**
     * This function return the javaScript code for
     * an onFocus event
     *
     * @return string - javascript code
     */
    function onFocus() {
        return NULL;
    }

    /**
     * This function return the javaScript code for
     * an onSubmit event
     *
     * @return string - javascript code
     */
    function onSubmit() {
        return NULL;
    }

    /**
     * This function return the javaScript code for
     * an onBlur event
     *
     * @return string - javascript code
     */
    function onBlur() {
        return NULL;
    }


    /**
     * this function retuns the javaScript code for
     * an onChange event
     *
     * @return string - javascript code
     */
    function onChange() {
        return NULL;
    }

    /**
     * This function builds the complete javaScript events code
     * for the element
     *
     * @return array - attributes
     */
    function _build_javascript() {

        $javascript = array();

        if (($js=$this->onClick()) != NULL) {
            $javascript[] = "onclick=\"" . $js . "\"";
        }

        if (($js=$this->onFocus()) != NULL) {
            $javascript[] = "onfocus=\"" . $js . "\"";
        }

        if (($js=$this->onSubmit()) != NULL) {
            $javascript[] = "onsubmit=\"" . $js . "\"";
        }

        if (($js=$this->onBlur()) != NULL) {
            $javascript[] = "onblur=\"" . $js . "\"";
        }

        if (($js=$this->onChange()) != NULL) {
            $javascript[] = "onchange=\"" . $js . "\"";
        }

        if (count($javascript)>0) {
            return $javascript;
        }
        else {
            return NULL;
        }
    }


    /**
     * This is a method for getting the JS needed
     * for the form tag's onsubmit attribute.
     *
     * @return string
     */
    function form_tag_onsubmit() {
        return '';
    }


    /********* rendering methods *********/


    /**
     * This function return the symbol used to
     * denote a required field
     *
     * @return string - required symbol
     */
    function get_required_symbol() {
        return $this->_required_field_marker;
    }

    /**
     * This allows you to customize the 
     * require string marker
     * 
     * @param string
     */
    function set_required_symbol($symbol) {
        $this->_required_field_marker;
    }

    /**
     * This function builds the element form attributes
     *
     * @return array attributes
     */
    function _build_element_attributes() {

        $attributes = $this->_attributes;

        if ($this->_style_attributes) {
            // build the css styles
            foreach ($this->_style_attributes as $name=>$value) {
                $style[] = $name . ":" . $value . ";";
            }
            $attributes["style"] = implode("", $style);
        }

        // set the element tag name
        $attributes["name"] = $this->get_element_name();

        if (($js = $this->_build_javascript()) != NULL) {
            // build javaScript attributes
            $attributes = array_merge($attributes, $js);
        }

        //see if its disabled
        if ($this->is_disabled()) {
            $attributes[] = "disabled";
        }

        return $attributes;
    }


    /**
     * This function builds and returns a
     * label object based on the label text
     * and error conditions
     *
     * @param FormContent object that holds the 
     *        required field marker
     * @return object SPANtag
     */
    function get_label($form_content=NULL) {

        $label = $this->get_label_text();
        $text = $label;

        if ($this->is_required()) {
            $text .= ' ' .  ($form_content ? $form_content->_required_field_marker : 
                             $this->get_required_symbol());
        }

        $span = html_span("formlabel", $text);

        if ($this->has_error()) {
            $span->set_tag_attribute("style","color:red;");
        }

        return $span;
    }


    /**
     * This function builds and returns the
     * form element object
     *
     * @return object
     */
    function get_element() {

        $span = new SPANtag($this->_build_element_attributes(), $this->get_value());

        return $span;
    }


    /**
     * This method returns the hidden version of this
     * element for a confirmation page.
     *
     * NOTE: This is called by the FormProcessor only.
     * It shouldn't be called manually.
     *
     * @return INPUTtag of type hidden
     */
    function get_confirm_element() {
        $values = $this->get_value();
        $name = $this->get_element_name();

        if (is_array($values)) {
            $c = container();
            foreach ( $values as $value ) {
                $c->add( form_hidden($name, $value ) );
            }
            return $c;
        } else {
            return form_hidden($name, $this->get_value() );
        }
    }

} // FormElement
?>
1	jonen	1.1	<?php
2			/**
3			* This file contains the base FormElement class.
4			*
5	jonen	1.3	* $Id: FormElement.inc,v 1.39 2004/03/25 21:02:57 hemna Exp $
6	jonen	1.1	*
7			* @author Walter A. Boring IV <waboring@buildabetterweb.com>
8			* @author Suren Markosyan <suren@bcsweb.com>
9			* @package phpHtmlLib
10			* @subpackage FormProcessing
11			*
12			* @copyright LGPL - See LICENCE
13			*
14			*/
15
16			/**
17			* This is the base FormElement object. It can be
18			* single form field such as a text input field,
19			* or a complex object.
20			*
21			* Usefull Functions
22			*
23			* get_value() - This gets the current
24			* 'value' of the FormElement.
25			* NOTE: This can be a 'complex' FormElement
26	jonen	1.3	* in which it may return an array of
27	jonen	1.1	* values.
28			*
29			* set_value() - Set the current value
30			* for this FormElement.
31			*
32			* get_label() - returns the label for this
33			* FormElement.
34	jonen	1.3	*
35	jonen	1.1	*
36			* @package phpHtmlLib
37			* @subpackage FormProcessing
38			*/
39			class FormElement {
40
41			/**
42			* Holds the elements label text
43			*
44			*/
45			var $_label_text = NULL;
46
47			/**
48			* Holds the elements initial value
49			*
50			*/
51			var $_value = NULL;
52
53			/**
54			* Indicates whether this elements
55			* final value is required and cannot
56			* be empty
57			*/
58			var $_is_required = TRUE;
59
60			/**
61	jonen	1.2	* holds the array of errors
62			* for this element.
63			*/
64			var $_errors = array();
65
66			/**
67	jonen	1.1	* Holds the error message text
68			* for validation errors, if any
69			*
70			*/
71			var $_error_message = NULL;
72
73			/**
74			* Holds the state of the last validation
75			* Sets to true in case of a validation error
76			*
77			*/
78			var $_has_error = FALSE;
79
80			/**
81			* Holds the name of the element
82			* as it appears in the form html tag
83			*
84			*/
85			var $_element_name = NULL;
86
87			/**
88			* Holds additional attributes for
89			* the elements html tag
90			*
91			*/
92			var $_attributes;
93
94			/**
95			* Holds additional style attributes for
96			* the elements html tag
97			*
98			*/
99			var $_style_attributes;
100
101			/**
102			* Indicates a disabled element
103			*
104			*/
105			var $_is_disabled = FALSE;
106
107	jonen	1.2	/**
108	jonen	1.3	* automatically strip slashes from
109	jonen	1.2	* form values?
110			*/
111			var $_stripslashes = FALSE;
112
113
114			/**
115			* This holds the name of the form
116			* for js that needs it
117			*/
118			var $_form_name;
119
120	jonen	1.3	/**
121			* This Form Element needs to
122			* propogate some js to the
123			* Form tag's onsubmit attribute
124			*
125			* @var string
126			*/
127			var $_has_form_on_submit = false;
128
129			/**
130			* This holds an array of FormElement objects
131			* that are slaves of this element
132			*/
133			var $_slave_elements;
134
135			/**
136			* The required field string
137			*
138			*/
139			var $_required_field_marker = "*";
140
141	jonen	1.1
142			/**
143			* The constructor
144			*
145			* @param label string - text label for the element
146			* @param bool required - is this a required element
147			*/
148			function FormElement($label, $required = TRUE) {
149
150			$this->set_label_text($label);
151			$this->set_required($required);
152
153			// create a unique name to be used in the html form
154			$this->create_element_name();
155
156			//This sets the initial value of the element
157			$this->set_value( $this->get_init_value() );
158			}
159
160	jonen	1.3	/**
161			* This function will return the
162			* slaves of this element
163			*
164			* @return array of slave elements
165			*/
166			function &get_slave_elements() {
167			return $this->_slave_elements;
168			}
169
170			/**
171			* This function will set the
172			* slaves of this element
173			*
174			* @param array of slave elements (element references &)
175			*/
176			function set_slave_elements($slaveElements) {
177			$this->_slave_elements = $slaveElements;
178			$this->set_data_all_slaves( $this->get_value() );
179			}
180
181
182			/**
183			* This function will set the
184			* data the parent wants to set for the slave
185			*
186			* @param the slave
187			* @param the value being set for the parent
188			*/
189			function set_slave_data(&$slave, $parentValue) {
190			; //override to set the data for the slave
191			}
192	jonen	1.1
193			/**
194			* This function will return the
195			* elements label text
196			*
197			* @return string
198			*/
199			function get_label_text() {
200			return $this->_label_text;
201			}
202
203			/**
204			* This function will set the
205			* label for the element
206			*
207			* @param label string
208			*/
209			function set_label_text($label) {
210			$this->_label_text = $label;
211			}
212
213			/**
214			* This function will return the
215			* elements value
216			*
217			* @return mixed
218			*/
219			function get_value() {
220	jonen	1.2	if ($this->_stripslashes) {
221			return stripslashes($this->_value);
222			} else {
223			return $this->_value;
224			}
225	jonen	1.1	}
226
227	jonen	1.3
228	jonen	1.1	/**
229			* This function will set the
230			* initial value for the element
231			*
232			* @param value mixed
233			*/
234			function set_value($value) {
235			$this->_value = $value;
236	jonen	1.3	$this->set_data_all_slaves($value);
237			}
238
239			/**
240			* This function will call set_slave_data for all slaves
241			* should be called when value of parent changes
242			*
243			* @param string - the current value of parent
244			*/
245			function set_data_all_slaves($parentValue){
246			$slaves = &$this->get_slave_elements();
247			$num_slaves = count($slaves);
248			if ($num_slaves) {
249			for($i=0; $i < $num_slaves; $i++){
250			$this->set_slave_data($slaves[$i], $parentValue);
251			}
252
253			}
254	jonen	1.1	}
255
256			/**
257	jonen	1.2	* in case anyone in JS land
258			* needs the name of the form that
259			* this element lives in
260	jonen	1.3	*
261	jonen	1.2	* @param string - the form name
262			*/
263			function set_form_name($name) {
264			$this->_form_name = $name;
265			}
266
267			/**
268	jonen	1.1	* This provides a method
269			* for the FormContent
270	jonen	1.3	* to get access to the
271	jonen	1.1	* text associated with a
272			* field. This is only available
273			* on FormElements that have text
274			* associated with a field.
275			* It is used during Confirmation
276			*
277	jonen	1.3	* @param mixed the value to look up
278	jonen	1.1	* @return string - the text associated
279			*/
280	jonen	1.3	function get_value_text() {
281	jonen	1.1	return $this->get_value();
282			}
283
284
285			/**
286			* This function set the elements
287			* required state
288			*
289			* @param bool required
290			*/
291			function set_required($required) {
292			$this->_is_required = $required;
293			}
294
295			/**
296			* Returns whether this elements
297			* final value cannot be empty
298			*
299			* @return bool requried
300			*/
301			function is_required() {
302			return $this->_is_required;
303			}
304
305
306			/**
307			* This returns the initial value of
308			* the element
309			*
310			* @return mixed
311			*/
312			function get_init_value() {
313	jonen	1.2	return @$_REQUEST[str_replace("[]","",$this->get_element_name())];
314	jonen	1.1	}
315
316
317			/**
318			* Sets the disabled element flag
319			*
320			* @param bool disabled
321			*/
322			function set_disabled($flag) {
323			$this->_is_disabled = $flag;
324			}
325
326			/**
327			* Returns the elements disabled
328			* state
329			*
330			* @return bool disabled
331			*/
332			function is_disabled() {
333			return $this->_is_disabled;
334			}
335
336	jonen	1.2	/**
337			* This sets the stripslashes flag for
338			* this object.
339			*
340			* @param boolean
341			*/
342			function set_stripslashes( $flag = TRUE ) {
343			$this->_stripslashes = $flag;
344			}
345
346	jonen	1.1
347			/******* Tag attributes methods *******/
348
349
350			/**
351			* add a single attribute (name="value")
352			*
353			* @param string $name attribute name
354			* @param mixed $value the value
355			*
356			*/
357			function set_attribute($name, $value = NULL) {
358			if ($value == NULL) {
359			$this->_attributes[] = $name;
360			}
361			else {
362			$this->_attributes[$name] = $value;
363			}
364			}
365
366			/**
367			* return a single attribute
368			*
369			* @param string $name attribute name
370			* @return mixed $value the value
371			*
372			*/
373			function get_attribute($name) {
374			return $this->_attributes[$name];
375			}
376
377			/**
378			* Sets elements title text
379			*
380			* @param string title
381			*/
382			function set_title($title) {
383			$this->set_attribute("title", $title);
384			}
385
386			/**
387			* Sets elements css attribute
388			*
389			* @param string $name attribute name
390			* @param mixed $value the value
391			*/
392			function set_style_attribute($name, $value) {
393			$this->_style_attributes[$name] = $value;
394			}
395
396	jonen	1.3	/**
397			* Sets the element's tab index
398			*
399			* @param int the # for the tabindex
400			*/
401			function set_tabindex($index) {
402			$this->set_attribute('tabindex', $index);
403			}
404
405			/**
406			* Gets the current tab index if any
407			*
408			* @return int returns 0 if there is none set.
409			*/
410			function get_tabindex() {
411			if (isset($this->_attributes['tabindex'])) {
412			return $this->_attributes['tabindex'];
413			} else {
414			return 0;
415			}
416			}
417
418	jonen	1.1
419			/******* Error handling methods *******/
420
421			/**
422			* Defines error message text and
423			* sets the error flag to true
424			*
425			* @param mesage text - error message
426	jonen	1.2	* @param label text - a label to provide
427			* for the error. This is
428			* only needed for a complex
429			* element that has multiple
430			* 'hidden/magic' fields.
431			*/
432			function set_error_message($message, $label=NULL) {
433			if ($label == NULL) {
434			$label = $this->get_label_text();
435			}
436			$this->_errors[] = array("label" => $label,
437			"message" => $message);
438			$this->_has_error = TRUE;
439			}
440
441			/**
442	jonen	1.3	* This returns the array of errors
443	jonen	1.2	* for this element
444	jonen	1.3	*
445	jonen	1.2	* @param array of errors
446	jonen	1.1	*/
447	jonen	1.2	function get_errors() {
448			return $this->_errors;
449	jonen	1.1	}
450
451
452			/**
453			* Returns the current error message
454			* if any
455			*
456			* @return mesage text - error message
457			*/
458			function get_error_message() {
459			return $this->_error_message;
460			}
461
462			/**
463			* Returns the current error state
464			*
465			*
466			* @return bool error state
467			*/
468	jonen	1.2	function has_error($label=NULL) {
469			if ($label==NULL) {
470			return $this->_has_error;
471			} else {
472			//they are looking for a specific error
473			foreach( $this->_errors as $error) {
474	jonen	1.3
475	jonen	1.2	if ($error['label'] == $label) {
476			return TRUE;
477			}
478			}
479			return FALSE;
480			}
481	jonen	1.1	}
482
483
484			/******* Element name handling methods *******/
485
486			/**
487			* This function creates element name
488			* used in the form based on the text label
489			* or any other parameters
490			*
491			*/
492			function create_element_name() {
493
494			$name = strtolower($this->get_label_text());
495			$len = strlen($name);
496
497			for ($i=0; $i<$len;$i++) {
498			if ((ord($name[$i])<97 \|\| ord($name[$i])>122) && (ord($name[$i])<48 \|\| ord($name[$i])>57))
499			$name[$i] = "_";
500			}
501
502	jonen	1.3	$this->set_element_name($name);
503			}
504
505			/**
506			* This allows you to force the element
507			* name to whatever you like, so you
508			* don't have to use the default name, which is
509			* generated based on the label.
510			*
511			* @param string the form element's name
512			* @return none
513			*/
514			function set_element_name($name) {
515	jonen	1.1	$this->_element_name = $name;
516			}
517
518			/**
519			* Returns the element name
520			* to be used in the form
521			*
522			* @return string form element name
523			*/
524			function get_element_name() {
525			return $this->_element_name;
526			}
527
528
529			/******* Validation methods *******/
530
531
532			/**
533			* This function performs the actual validation
534			* It is called only if the validation is required by
535			* this element
536			*
537			* This function is responsible for performing complete
538			* validation and setting the appropriate error message
539			* in case of a failed validation
540			*
541	jonen	1.2	* @param FormValidation object.
542	jonen	1.1	*/
543	jonen	1.2	function validate(&$_FormValidation) {
544	jonen	1.1	return TRUE;
545			}
546
547
548			/**
549			* This function checks if the validation
550			* is nesseccary and calls the validate method
551			*
552	jonen	1.2	* @param FormValidation object.
553	jonen	1.1	*/
554	jonen	1.2	function _do_validation(&$_FormValidation) {
555			$value = $this->get_value();
556			$has_value = FALSE;
557			if (is_array($value)) {
558			foreach($value as $entry) {
559			if ($entry != NULL) {
560			$has_value = TRUE;
561			}
562			}
563			} else {
564			if ($value != NULL) {
565			$has_value = TRUE;
566			}
567			}
568
569			if ($has_value && !$this->is_disabled()) {
570			return $this->validate($_FormValidation);
571	jonen	1.1	} else if ($this->is_required()) {
572			$this->set_error_message("This field cannot be empty");
573			return FALSE;
574			} else {
575			return TRUE;
576			}
577			}
578
579
580			/******* JavaScript event methods *******/
581
582	jonen	1.2
583			/**
584			* This method is used for adding any javascript
585			* that is used by this element. This will automatically
586			* get called and added to the page by the FormProcessor
587			*
588			* @return string - raw js
589			*/
590			function javascript() {
591			return NULL;
592			}
593
594	jonen	1.1	/**
595			* This function return the javaScript code for
596			* an onClick event
597			*
598			* @return string - javascript code
599			*/
600			function onClick() {
601			return NULL;
602			}
603
604			/**
605			* This function return the javaScript code for
606			* an onFocus event
607			*
608			* @return string - javascript code
609			*/
610			function onFocus() {
611			return NULL;
612			}
613
614			/**
615			* This function return the javaScript code for
616			* an onSubmit event
617			*
618			* @return string - javascript code
619			*/
620			function onSubmit() {
621			return NULL;
622			}
623
624			/**
625			* This function return the javaScript code for
626			* an onBlur event
627			*
628			* @return string - javascript code
629			*/
630			function onBlur() {
631			return NULL;
632			}
633
634
635			/**
636			* this function retuns the javaScript code for
637			* an onChange event
638			*
639			* @return string - javascript code
640			*/
641			function onChange() {
642			return NULL;
643			}
644
645			/**
646			* This function builds the complete javaScript events code
647			* for the element
648			*
649			* @return array - attributes
650			*/
651			function _build_javascript() {
652
653			$javascript = array();
654
655			if (($js=$this->onClick()) != NULL) {
656	jonen	1.2	$javascript[] = "onclick=\"" . $js . "\"";
657	jonen	1.1	}
658
659			if (($js=$this->onFocus()) != NULL) {
660	jonen	1.2	$javascript[] = "onfocus=\"" . $js . "\"";
661	jonen	1.1	}
662
663			if (($js=$this->onSubmit()) != NULL) {
664	jonen	1.2	$javascript[] = "onsubmit=\"" . $js . "\"";
665	jonen	1.1	}
666
667			if (($js=$this->onBlur()) != NULL) {
668	jonen	1.2	$javascript[] = "onblur=\"" . $js . "\"";
669	jonen	1.1	}
670
671			if (($js=$this->onChange()) != NULL) {
672	jonen	1.2	$javascript[] = "onchange=\"" . $js . "\"";
673	jonen	1.1	}
674
675			if (count($javascript)>0) {
676			return $javascript;
677			}
678			else {
679			return NULL;
680			}
681			}
682
683
684	jonen	1.3	/**
685			* This is a method for getting the JS needed
686			* for the form tag's onsubmit attribute.
687			*
688			* @return string
689			*/
690			function form_tag_onsubmit() {
691			return '';
692			}
693
694
695	jonen	1.1	/******* rendering methods *******/
696
697
698			/**
699			* This function return the symbol used to
700			* denote a required field
701			*
702			* @return string - required symbol
703			*/
704			function get_required_symbol() {
705	jonen	1.3	return $this->_required_field_marker;
706			}
707
708			/**
709			* This allows you to customize the
710			* require string marker
711			*
712			* @param string
713			*/
714			function set_required_symbol($symbol) {
715			$this->_required_field_marker;
716	jonen	1.1	}
717
718			/**
719			* This function builds the element form attributes
720			*
721			* @return array attributes
722			*/
723			function _build_element_attributes() {
724
725			$attributes = $this->_attributes;
726
727			if ($this->_style_attributes) {
728			// build the css styles
729			foreach ($this->_style_attributes as $name=>$value) {
730			$style[] = $name . ":" . $value . ";";
731			}
732			$attributes["style"] = implode("", $style);
733			}
734
735			// set the element tag name
736			$attributes["name"] = $this->get_element_name();
737
738			if (($js = $this->_build_javascript()) != NULL) {
739			// build javaScript attributes
740			$attributes = array_merge($attributes, $js);
741			}
742
743			//see if its disabled
744			if ($this->is_disabled()) {
745			$attributes[] = "disabled";
746			}
747
748			return $attributes;
749			}
750
751
752			/**
753			* This function builds and returns a
754			* label object based on the label text
755			* and error conditions
756			*
757	jonen	1.3	* @param FormContent object that holds the
758			* required field marker
759	jonen	1.1	* @return object SPANtag
760			*/
761	jonen	1.3	function get_label($form_content=NULL) {
762	jonen	1.1
763			$label = $this->get_label_text();
764	jonen	1.3	$text = $label;
765	jonen	1.1
766	jonen	1.3	if ($this->is_required()) {
767			$text .= ' ' . ($form_content ? $form_content->_required_field_marker :
768			$this->get_required_symbol());
769			}
770	jonen	1.1
771	jonen	1.3	$span = html_span("formlabel", $text);
772	jonen	1.1
773	jonen	1.3	if ($this->has_error()) {
774	jonen	1.1	$span->set_tag_attribute("style","color:red;");
775			}
776
777			return $span;
778			}
779
780
781			/**
782			* This function builds and returns the
783			* form element object
784			*
785			* @return object
786			*/
787			function get_element() {
788
789			$span = new SPANtag($this->_build_element_attributes(), $this->get_value());
790
791			return $span;
792	jonen	1.3	}
793
794
795			/**
796			* This method returns the hidden version of this
797			* element for a confirmation page.
798			*
799			* NOTE: This is called by the FormProcessor only.
800			* It shouldn't be called manually.
801			*
802			* @return INPUTtag of type hidden
803			*/
804			function get_confirm_element() {
805			$values = $this->get_value();
806			$name = $this->get_element_name();
807
808			if (is_array($values)) {
809			$c = container();
810			foreach ( $values as $value ) {
811			$c->add( form_hidden($name, $value ) );
812			}
813			return $c;
814			} else {
815			return form_hidden($name, $this->get_value() );
816			}
817	jonen	1.1	}
818
819			} // FormElement
820			?>
MailToCvsAdmin">MailToCvsAdmin	ViewVC Help
Powered by ViewVC 1.1.26