MDL-14589 initial file storage implementation, temporary file manager, migration...
[moodle.git] / lib / formslib.php
1 <?php // $Id$
2 /**
3  * formslib.php - library of classes for creating forms in Moodle, based on PEAR QuickForms.
4  *
5  * To use formslib then you will want to create a new file purpose_form.php eg. edit_form.php
6  * and you want to name your class something like {modulename}_{purpose}_form. Your class will
7  * extend moodleform overriding abstract classes definition and optionally defintion_after_data
8  * and validation.
9  *
10  * See examples of use of this library in course/edit.php and course/edit_form.php
11  *
12  * A few notes :
13  *      form defintion is used for both printing of form and processing and should be the same
14  *              for both or you may lose some submitted data which won't be let through.
15  *      you should be using setType for every form element except select, radio or checkbox
16  *              elements, these elements clean themselves.
17  *
18  *
19  * @author  Jamie Pratt
20  * @version $Id$
21  * @license http://www.gnu.org/copyleft/gpl.html GNU Public License
22  */
24 //setup.php icludes our hacked pear libs first
25 require_once 'HTML/QuickForm.php';
26 require_once 'HTML/QuickForm/DHTMLRulesTableless.php';
27 require_once 'HTML/QuickForm/Renderer/Tableless.php';
29 require_once $CFG->libdir.'/uploadlib.php'; // TODO: remove
31 /**
32  * Callback called when PEAR throws an error
33  *
34  * @param PEAR_Error $error
35  */
36 function pear_handle_error($error){
37     echo '<strong>'.$error->GetMessage().'</strong> '.$error->getUserInfo();
38     echo '<br /> <strong>Backtrace </strong>:';
39     print_object($error->backtrace);
40 }
42 if ($CFG->debug >= DEBUG_ALL){
43     PEAR::setErrorHandling(PEAR_ERROR_CALLBACK, 'pear_handle_error');
44 }
47 /**
48  * Moodle specific wrapper that separates quickforms syntax from moodle code. You won't directly
49  * use this class you should write a class definition which extends this class or a more specific
50  * subclass such a moodleform_mod for each form you want to display and/or process with formslib.
51  *
52  * You will write your own definition() method which performs the form set up.
53  */
54 class moodleform {
55     protected $_formname;       // form name
56     /**
57      * quickform object definition
58      *
59      * @var MoodleQuickForm
60      */
61     protected $_form;
62     /**
63      * globals workaround
64      *
65      * @var array
66      */
67     protected $_customdata;
68     /**
69      * definition_after_data executed flag
70      * @var definition_finalized
71      */
72     protected $_definition_finalized = false;
74     /**
75      * The constructor function calls the abstract function definition() and it will then
76      * process and clean and attempt to validate incoming data.
77      *
78      * It will call your custom validate method to validate data and will also check any rules
79      * you have specified in definition using addRule
80      *
81      * The name of the form (id attribute of the form) is automatically generated depending on
82      * the name you gave the class extending moodleform. You should call your class something
83      * like
84      *
85      * @param mixed $action the action attribute for the form. If empty defaults to auto detect the
86      *                  current url. If a moodle_url object then outputs params as hidden variables.
87      * @param array $customdata if your form defintion method needs access to data such as $course
88      *               $cm, etc. to construct the form definition then pass it in this array. You can
89      *               use globals for somethings.
90      * @param string $method if you set this to anything other than 'post' then _GET and _POST will
91      *               be merged and used as incoming data to the form.
92      * @param string $target target frame for form submission. You will rarely use this. Don't use
93      *                  it if you don't need to as the target attribute is deprecated in xhtml
94      *                  strict.
95      * @param mixed $attributes you can pass a string of html attributes here or an array.
96      * @return moodleform
97      */
98     function moodleform($action=null, $customdata=null, $method='post', $target='', $attributes=null, $editable=true) {
99         if (empty($action)){
100             $action = strip_querystring(qualified_me());
101         }
103         $this->_formname = get_class($this); // '_form' suffix kept in order to prevent collisions of form id and other element
104         $this->_customdata = $customdata;
105         $this->_form =& new MoodleQuickForm($this->_formname, $method, $action, $target, $attributes);
106         if (!$editable){
107             $this->_form->hardFreeze();
108         }
110         $this->definition();
112         $this->_form->addElement('hidden', 'sesskey', null); // automatic sesskey protection
113         $this->_form->setDefault('sesskey', sesskey());
114         $this->_form->addElement('hidden', '_qf__'.$this->_formname, null);   // form submission marker
115         $this->_form->setDefault('_qf__'.$this->_formname, 1);
116         $this->_form->_setDefaultRuleMessages();
118         // we have to know all input types before processing submission ;-)
119         $this->_process_submission($method);
120     }
122     /**
123      * To autofocus on first form element or first element with error.
124      *
125      * @param string $name if this is set then the focus is forced to a field with this name
126      *
127      * @return string  javascript to select form element with first error or
128      *                  first element if no errors. Use this as a parameter
129      *                  when calling print_header
130      */
131     function focus($name=NULL) {
132         $form =& $this->_form;
133         $elkeys = array_keys($form->_elementIndex);
134         $error = false;
135         if (isset($form->_errors) &&  0 != count($form->_errors)){
136             $errorkeys = array_keys($form->_errors);
137             $elkeys = array_intersect($elkeys, $errorkeys);
138             $error = true;
139         }
141         if ($error or empty($name)) {
142             $names = array();
143             while (empty($names) and !empty($elkeys)) {
144                 $el = array_shift($elkeys);
145                 $names = $form->_getElNamesRecursive($el);
146             }
147             if (!empty($names)) {
148                 $name = array_shift($names);
149             }
150         }
152         $focus = '';
153         if (!empty($name)) {
154             $focus = 'forms[\''.$form->getAttribute('id').'\'].elements[\''.$name.'\']';
155         }
157         return $focus;
158      }
160     /**
161      * Internal method. Alters submitted data to be suitable for quickforms processing.
162      * Must be called when the form is fully set up.
163      */
164     function _process_submission($method) {
165         $submission = array();
166         if ($method == 'post') {
167             if (!empty($_POST)) {
168                 $submission = $_POST;
169             }
170         } else {
171             $submission = array_merge_recursive($_GET, $_POST); // emulate handling of parameters in xxxx_param()
172         }
174         // following trick is needed to enable proper sesskey checks when using GET forms
175         // the _qf__.$this->_formname serves as a marker that form was actually submitted
176         if (array_key_exists('_qf__'.$this->_formname, $submission) and $submission['_qf__'.$this->_formname] == 1) {
177             if (!confirm_sesskey()) {
178                 print_error('invalidseeky');
179             }
180             $files = $_FILES;
181         } else {
182             $submission = array();
183             $files = array();
184         }
186         $this->_form->updateSubmission($submission, $files);
187     }
189     /**
190      * Internal method. Validates all uploaded files.
191      */
192     function _validate_files(&$files) {
193         global $CFG, $COURSE;
195         $files = array();
197         if (empty($_FILES)) {
198             // we do not need to do any checks because no files were submitted
199             // note: server side rules do not work for files - use custom verification in validate() instead
200             return true;
201         }
203         $errors = array();
204         $filenames = array();
206         // now check that we really want each file
207         foreach ($_FILES as $elname=>$file) {
208             $required = $this->_form->isElementRequired($elname);
210             if ($file['error'] == 4 and $file['size'] == 0) {
211                 if ($required) {
212                     $errors[$elname] = get_string('required');
213                 }
214                 unset($_FILES[$elname]);
215                 continue;
216             }
218             if ($file['error'] > 0) {
219                 switch ($file['error']) {
220                 case 1: // UPLOAD_ERR_INI_SIZE
221                     $errmessage = get_string('uploadserverlimit');
222                     break;
224                 case 2: // UPLOAD_ERR_FORM_SIZE
225                     $errmessage = get_string('uploadformlimit');
226                     break;
228                 case 3: // UPLOAD_ERR_PARTIAL
229                     $errmessage = get_string('uploadpartialfile');
230                     break;
232                 case 4: // UPLOAD_ERR_NO_FILE
233                     $errmessage = get_string('uploadnofilefound');
234                     break;
236                 // Note: there is no error with a value of 5
238                 case 6: // UPLOAD_ERR_NO_TMP_DIR
239                     $errmessage = get_string('uploadnotempdir');
240                     break;
242                 case 7: // UPLOAD_ERR_CANT_WRITE
243                     $errmessage = get_string('uploadcantwrite');
244                     break;
246                 case 8: // UPLOAD_ERR_EXTENSION
247                     $errmessage = get_string('uploadextension');
248                     break;
250                 default:
251                     $errmessage = get_string('uploadproblem', $file['name']);
252                 }
253                 $errors[$elname] = $errmessage;
254                 unset($_FILES[$elname]);
255                 continue;
256             }
258             if (!is_uploaded_file($file['tmp_name'])) {
259                 // TODO: improve error message
260                 $errors[$elname] = get_string('error');
261                 unset($_FILES[$elname]);
262                 continue;
263             }
265             if (!$this->_form->elementExists($elname) or !$this->_form->getElementType($elname)=='file') {
266                 // hmm, this file was not requested
267                 unset($_FILES[$elname]);
268                 continue;
269             }
271 /*
272   // TODO: rethink the file scanning
273             if ($CFG->runclamonupload) {
274                 if (!clam_scan_moodle_file($_FILES[$elname], $COURSE)) {
275                     $errors[$elname] = $_FILES[$elname]['uploadlog'];
276                     unset($_FILES[$elname]);
277                     continue;
278                 }
279             }
280 */
281             $filename = clean_param($_FILES[$elname]['name'], PARAM_FILE);
282             if ($filename === '') {
283                 // TODO: improve error message - wrong chars
284                 $errors[$elname] = get_string('error');
285                 unset($_FILES[$elname]);
286                 continue;
287             }
288             if (in_array($filename, $filenames)) {
289                 // TODO: improve error message - duplicate name
290                 $errors[$elname] = get_string('error');
291                 unset($_FILES[$elname]);
292                 continue;
293             }
294             $filenames[] = $filename;
295             $_FILES[$elname]['name'] = $filename;
297             $files[$elname] = $_FILES[$elname]['tmp_name'];
298         }
300         // return errors if found
301         if (count($errors) == 0){
302             return true;
304         } else {
305             $files = array();
306             return $errors;
307         }
308     }
310     /**
311      * Load in existing data as form defaults. Usually new entry defaults are stored directly in
312      * form definition (new entry form); this function is used to load in data where values
313      * already exist and data is being edited (edit entry form).
314      *
315      * note: $slashed param removed
316      *
317      * @param mixed $default_values object or array of default values
318      * @param bool $slased true if magic quotes applied to data values
319      */
320     function set_data($default_values) {
321         if (is_object($default_values)) {
322             $default_values = (array)$default_values;
323         }
324         $this->_form->setDefaults($default_values);
325     }
327     function set_upload_manager($um=false) {
328         debugging('Not used anymore, please fix code!');
329     }
331     /**
332      * Check that form was submitted. Does not check validity of submitted data.
333      *
334      * @return bool true if form properly submitted
335      */
336     function is_submitted() {
337         return $this->_form->isSubmitted();
338     }
340     function no_submit_button_pressed(){
341         static $nosubmit = null; // one check is enough
342         if (!is_null($nosubmit)){
343             return $nosubmit;
344         }
345         $mform =& $this->_form;
346         $nosubmit = false;
347         if (!$this->is_submitted()){
348             return false;
349         }
350         foreach ($mform->_noSubmitButtons as $nosubmitbutton){
351             if (optional_param($nosubmitbutton, 0, PARAM_RAW)){
352                 $nosubmit = true;
353                 break;
354             }
355         }
356         return $nosubmit;
357     }
360     /**
361      * Check that form data is valid.
362      *
363      * @return bool true if form data valid
364      */
365     function is_validated() {
366         static $validated = null; // one validation is enough
367         $mform =& $this->_form;
369         //finalize the form definition before any processing
370         if (!$this->_definition_finalized) {
371             $this->_definition_finalized = true;
372             $this->definition_after_data();
373         }
375         if ($this->no_submit_button_pressed()){
376             return false;
377         } elseif ($validated === null) {
378             $internal_val = $mform->validate();
380             $files = array();
381             $file_val = $this->_validate_files($files);
382             if ($file_val !== true) {
383                 if (!empty($file_val)) {
384                     foreach ($file_val as $element=>$msg) {
385                         $mform->setElementError($element, $msg);
386                     }
387                 }
388                 $file_val = false;
389             }
391             $data = $mform->exportValues(null, false);
392             $moodle_val = $this->validation($data, $files);
393             if ((is_array($moodle_val) && count($moodle_val)!==0)) {
394                 // non-empty array means errors
395                 foreach ($moodle_val as $element=>$msg) {
396                     $mform->setElementError($element, $msg);
397                 }
398                 $moodle_val = false;
400             } else {
401                 // anything else means validation ok
402                 $moodle_val = true;
403             }
405             $validated = ($internal_val and $moodle_val and $file_val);
406         }
407         return $validated;
408     }
410     /**
411      * Return true if a cancel button has been pressed resulting in the form being submitted.
412      *
413      * @return boolean true if a cancel button has been pressed
414      */
415     function is_cancelled(){
416         $mform =& $this->_form;
417         if ($mform->isSubmitted()){
418             foreach ($mform->_cancelButtons as $cancelbutton){
419                 if (optional_param($cancelbutton, 0, PARAM_RAW)){
420                     return true;
421                 }
422             }
423         }
424         return false;
425     }
427     /**
428      * Return submitted data if properly submitted or returns NULL if validation fails or
429      * if there is no submitted data.
430      *
431      * note: $slashed param removed
432      *
433      * @return object submitted data; NULL if not valid or not submitted
434      */
435     function get_data() {
436         $mform =& $this->_form;
438         if ($this->is_submitted() and $this->is_validated()) {
439             $data = $mform->exportValues();
440             unset($data['sesskey']); // we do not need to return sesskey
441             unset($data['_qf__'.$this->_formname]);   // we do not need the submission marker too
442             if (empty($data)) {
443                 return NULL;
444             } else {
445                 return (object)$data;
446             }
447         } else {
448             return NULL;
449         }
450     }
452     /**
453      * Return submitted data without validation or NULL if there is no submitted data.
454      * note: $slashed param removed
455      *
456      * @return object submitted data; NULL if not submitted
457      */
458     function get_submitted_data() {
459         $mform =& $this->_form;
461         if ($this->is_submitted()) {
462             $data = $mform->exportValues();
463             unset($data['sesskey']); // we do not need to return sesskey
464             unset($data['_qf__'.$this->_formname]);   // we do not need the submission marker too
465             if (empty($data)) {
466                 return NULL;
467             } else {
468                 return (object)$data;
469             }
470         } else {
471             return NULL;
472         }
473     }
475     /**
476      * Save verified uploaded files into directory. Upload process can be customised from definition()
477      * NOTE: please use save_stored_file() or save_file()
478      */
479     function save_files($destination) {
480         debugging('Not used anymore, please fix code! Use save_stored_file() or save_file() instead');
481         return false;
482     }
484     /**
485      * Returns name of uploaded file.
486      * @param string $elname, first element if null
487      * @return mixed false in case of failure, string if ok
488      */
489     function get_new_filename($elname=null) {
490         if (!$this->is_submitted() or !$this->is_validated()) {
491             return false;
492         }
494         if (is_null($elname)) {
495             if (empty($_FILES)) {
496                 return false;
497             }
498             reset($_FILES);
499             $elname = key($_FILES);
500         }
501         if (!isset($_FILES[$elname])) {
502             return false;
503         }
505         return $_FILES[$elname]['name'];
506     }
508     /**
509      * Save file to standard filesystem
510      * @param string $elname name of element
511      * @param string $pathname full path name of file
512      * @param bool $override override file if exists
513      * @return bool success
514      */
515     function save_file($elname, $pathname, $override=false) {
516         if (!$this->is_submitted() or !$this->is_validated()) {
517             return false;
518         }
520         if (!isset($_FILES[$elname])) {
521             return false;
522         }
524         if (file_exists($pathname)) {
525             if ($override) {
526                 if (!@unlink($pathname)) {
527                     return false;
528                 }
529             } else {
530                 return false;
531             }
532         }
533         if (!$temp = @fopen($_FILES[$elname]['tmp_name'], "rb")) {
534             return false;
535         }
536         if (!$file = @fopen($pathname, "wb")) {
537             return false;
538         }
540         while (!feof($temp)) {
541             $data = fread($temp, 65536);
542             fwrite($file, $data);
543         }
544         fclose($file);
545         fclose($temp);
547         return true;
548     }
550     /**
551      * Save file to local filesystem pool
552      * @param string $elname name of element
553      * @param int $contextid
554      * @param string $filearea
555      * @param string $filepath
556      * @param string $filename - use specified filename, if not specified name of uploaded file used
557      * @param bool $override override file if exists
558      * @param int $userid
559      * @return mixed stored_file object or false if error; may throw exception if duplicate found
560      */
561     function save_stored_file($elname, $contextid, $filearea, $itemid, $filepath, $filename=null, $override=false, $userid=null) {
562         if (!$this->is_submitted() or !$this->is_validated()) {
563             return false;
564         }
566         if (!isset($_FILES[$elname])) {
567             return false;
568         }
570         $filename = is_null($filename) ? $_FILES[$elname]['name'] : $filename;
572         $fs = get_file_storage();
574         if ($file = $fs->get_file($contextid, $filearea, $itemid, $filepath, $filename)) {
575             if ($override) {
576                 $file->delete();
577             } else {
578                 return false;
579             }
580         }
582         $file_record = new object();
583         $file_record->contextid = $contextid;
584         $file_record->filearea  = $filearea;
585         $file_record->itemid    = $itemid;
586         $file_record->filepath  = $filepath;
587         $file_record->filename  = $filename;
588         $file_record->userid    = $userid;
590         return $fs->create_file_from_pathname($file_record, $_FILES[$elname]['tmp_name']);
591     }
593     /**
594      * Get content of uploaded file.
595      * @param $element name of file upload element
596      * @return mixed false in case of failure, string if ok
597      */
598     function get_file_content($elname) {
599         if (!$this->is_submitted() or !$this->is_validated()) {
600             return false;
601         }
603         if (!isset($_FILES[$elname])) {
604             return false;
605         }
607         if (!$file = @fopen($_FILES[$elname]['tmp_name'], "rb")) {
608             return false;
609         }
611         $data = '';
612         while (!feof($file)) {
613             $data .= fread($file, 4048);
614         }
615         fclose($file);
617         return $data;
618     }
620     /**
621      * Print html form.
622      */
623     function display() {
624         //finalize the form definition if not yet done
625         if (!$this->_definition_finalized) {
626             $this->_definition_finalized = true;
627             $this->definition_after_data();
628         }
629         $this->_form->display();
630     }
632     /**
633      * Abstract method - always override!
634      *
635      * If you need special handling of uploaded files, create instance of $this->_upload_manager here.
636      */
637     function definition() {
638         print_error('mustbeoverriden', 'form', '', get_class($this));
639     }
641     /**
642      * Dummy stub method - override if you need to setup the form depending on current
643      * values. This method is called after definition(), data submission and set_data().
644      * All form setup that is dependent on form values should go in here.
645      */
646     function definition_after_data(){
647     }
649     /**
650      * Dummy stub method - override if you needed to perform some extra validation.
651      * If there are errors return array of errors ("fieldname"=>"error message"),
652      * otherwise true if ok.
653      *
654      * Server side rules do not work for uploaded files, implement serverside rules here if needed.
655      *
656      * @param array $data array of ("fieldname"=>value) of submitted data
657      * @param array $files array of uploaded files "element_name"=>tmp_file_path
658      * @return array of "element_name"=>"error_description" if there are errors,
659      *               or an empty array if everything is OK (true allowed for backwards compatibility too).
660      */
661     function validation($data, $files) {
662         return array();
663     }
665     /**
666      * Method to add a repeating group of elements to a form.
667      *
668      * @param array $elementobjs Array of elements or groups of elements that are to be repeated
669      * @param integer $repeats no of times to repeat elements initially
670      * @param array $options Array of options to apply to elements. Array keys are element names.
671      *                      This is an array of arrays. The second sets of keys are the option types
672      *                      for the elements :
673      *                          'default' - default value is value
674      *                          'type' - PARAM_* constant is value
675      *                          'helpbutton' - helpbutton params array is value
676      *                          'disabledif' - last three moodleform::disabledIf()
677      *                                           params are value as an array
678      * @param string $repeathiddenname name for hidden element storing no of repeats in this form
679      * @param string $addfieldsname name for button to add more fields
680      * @param int $addfieldsno how many fields to add at a time
681      * @param string $addstring name of button, {no} is replaced by no of blanks that will be added.
682      * @param boolean $addbuttoninside if true, don't call closeHeaderBefore($addfieldsname). Default false.
683      * @return int no of repeats of element in this page
684      */
685     function repeat_elements($elementobjs, $repeats, $options, $repeathiddenname,
686             $addfieldsname, $addfieldsno=5, $addstring=null, $addbuttoninside=false){
687         if ($addstring===null){
688             $addstring = get_string('addfields', 'form', $addfieldsno);
689         } else {
690             $addstring = str_ireplace('{no}', $addfieldsno, $addstring);
691         }
692         $repeats = optional_param($repeathiddenname, $repeats, PARAM_INT);
693         $addfields = optional_param($addfieldsname, '', PARAM_TEXT);
694         if (!empty($addfields)){
695             $repeats += $addfieldsno;
696         }
697         $mform =& $this->_form;
698         $mform->registerNoSubmitButton($addfieldsname);
699         $mform->addElement('hidden', $repeathiddenname, $repeats);
700         //value not to be overridden by submitted value
701         $mform->setConstants(array($repeathiddenname=>$repeats));
702         for ($i=0; $i<$repeats; $i++) {
703             foreach ($elementobjs as $elementobj){
704                 $elementclone = clone($elementobj);
705                 $name = $elementclone->getName();
706                 if (!empty($name)){
707                     $elementclone->setName($name."[$i]");
708                 }
709                 if (is_a($elementclone, 'HTML_QuickForm_header')){
710                     $value=$elementclone->_text;
711                     $elementclone->setValue(str_replace('{no}', ($i+1), $value));
713                 } else {
714                     $value=$elementclone->getLabel();
715                     $elementclone->setLabel(str_replace('{no}', ($i+1), $value));
717                 }
719                 $mform->addElement($elementclone);
720             }
721         }
722         for ($i=0; $i<$repeats; $i++) {
723             foreach ($options as $elementname => $elementoptions){
724                 $pos=strpos($elementname, '[');
725                 if ($pos!==FALSE){
726                     $realelementname = substr($elementname, 0, $pos+1)."[$i]";
727                     $realelementname .= substr($elementname, $pos+1);
728                 }else {
729                     $realelementname = $elementname."[$i]";
730                 }
731                 foreach ($elementoptions as  $option => $params){
733                     switch ($option){
734                         case 'default' :
735                             $mform->setDefault($realelementname, $params);
736                             break;
737                         case 'helpbutton' :
738                             $mform->setHelpButton($realelementname, $params);
739                             break;
740                         case 'disabledif' :
741                             $params = array_merge(array($realelementname), $params);
742                             call_user_func_array(array(&$mform, 'disabledIf'), $params);
743                             break;
744                         case 'rule' :
745                             if (is_string($params)){
746                                 $params = array(null, $params, null, 'client');
747                             }
748                             $params = array_merge(array($realelementname), $params);
749                             call_user_func_array(array(&$mform, 'addRule'), $params);
750                             break;
752                     }
753                 }
754             }
755         }
756         $mform->addElement('submit', $addfieldsname, $addstring);
758         if (!$addbuttoninside) {
759             $mform->closeHeaderBefore($addfieldsname);
760         }
762         return $repeats;
763     }
765     /**
766      * Adds a link/button that controls the checked state of a group of checkboxes.
767      * @param int    $groupid The id of the group of advcheckboxes this element controls
768      * @param string $text The text of the link. Defaults to "select all/none"
769      * @param array  $attributes associative array of HTML attributes
770      * @param int    $originalValue The original general state of the checkboxes before the user first clicks this element
771      */
772     function add_checkbox_controller($groupid, $buttontext, $attributes, $originalValue = 0) {
773         global $CFG;
774         if (empty($text)) {
775             $text = get_string('selectallornone', 'form');
776         }
778         $mform = $this->_form;
779         $select_value = optional_param('checkbox_controller'. $groupid, null, PARAM_INT);
781         if ($select_value == 0 || is_null($select_value)) {
782             $new_select_value = 1;
783         } else {
784             $new_select_value = 0;
785         }
787         $mform->addElement('hidden', "checkbox_controller$groupid");
788         $mform->setConstants(array("checkbox_controller$groupid" => $new_select_value));
790         // Locate all checkboxes for this group and set their value, IF the optional param was given
791         if (!is_null($select_value)) {
792             foreach ($this->_form->_elements as $element) {
793                 if ($element->getAttribute('class') == "checkboxgroup$groupid") {
794                     $mform->setConstants(array($element->getAttribute('name') => $select_value));
795                 }
796             }
797         }
799         $checkbox_controller_name = 'nosubmit_checkbox_controller' . $groupid;
800         $mform->registerNoSubmitButton($checkbox_controller_name);
802         // Prepare Javascript for submit element
803         $js = "\n//<![CDATA[\n";
804         if (!defined('HTML_QUICKFORM_CHECKBOXCONTROLLER_EXISTS')) {
805             $js .= <<<EOS
806 function html_quickform_toggle_checkboxes(group) {
807     var checkboxes = getElementsByClassName(document, 'input', 'checkboxgroup' + group);
808     var newvalue = false;
809     var global = eval('html_quickform_checkboxgroup' + group + ';');
810     if (global == 1) {
811         eval('html_quickform_checkboxgroup' + group + ' = 0;');
812         newvalue = '';
813     } else {
814         eval('html_quickform_checkboxgroup' + group + ' = 1;');
815         newvalue = 'checked';
816     }
818     for (i = 0; i < checkboxes.length; i++) {
819         checkboxes[i].checked = newvalue;
820     }
822 EOS;
823             define('HTML_QUICKFORM_CHECKBOXCONTROLLER_EXISTS', true);
824         }
825         $js .= "\nvar html_quickform_checkboxgroup$groupid=$originalValue;\n";
827         $js .= "//]]>\n";
829         require_once("$CFG->libdir/form/submitlink.php");
830         $submitlink = new MoodleQuickForm_submitlink($checkbox_controller_name, $attributes);
831         $submitlink->_js = $js;
832         $submitlink->_onclick = "html_quickform_toggle_checkboxes($groupid); return false;";
833         $mform->addElement($submitlink);
834         $mform->setDefault($checkbox_controller_name, $text);
835     }
837     /**
838      * Use this method to a cancel and submit button to the end of your form. Pass a param of false
839      * if you don't want a cancel button in your form. If you have a cancel button make sure you
840      * check for it being pressed using is_cancelled() and redirecting if it is true before trying to
841      * get data with get_data().
842      *
843      * @param boolean $cancel whether to show cancel button, default true
844      * @param string $submitlabel label for submit button, defaults to get_string('savechanges')
845      */
846     function add_action_buttons($cancel = true, $submitlabel=null){
847         if (is_null($submitlabel)){
848             $submitlabel = get_string('savechanges');
849         }
850         $mform =& $this->_form;
851         if ($cancel){
852             //when two elements we need a group
853             $buttonarray=array();
854             $buttonarray[] = &$mform->createElement('submit', 'submitbutton', $submitlabel);
855             $buttonarray[] = &$mform->createElement('cancel');
856             $mform->addGroup($buttonarray, 'buttonar', '', array(' '), false);
857             $mform->closeHeaderBefore('buttonar');
858         } else {
859             //no group needed
860             $mform->addElement('submit', 'submitbutton', $submitlabel);
861             $mform->closeHeaderBefore('submitbutton');
862         }
863     }
866 /**
867  * You never extend this class directly. The class methods of this class are available from
868  * the private $this->_form property on moodleform and its children. You generally only
869  * call methods on this class from within abstract methods that you override on moodleform such
870  * as definition and definition_after_data
871  *
872  */
873 class MoodleQuickForm extends HTML_QuickForm_DHTMLRulesTableless {
874     var $_types = array();
875     var $_dependencies = array();
876     /**
877      * Array of buttons that if pressed do not result in the processing of the form.
878      *
879      * @var array
880      */
881     var $_noSubmitButtons=array();
882     /**
883      * Array of buttons that if pressed do not result in the processing of the form.
884      *
885      * @var array
886      */
887     var $_cancelButtons=array();
889     /**
890      * Array whose keys are element names. If the key exists this is a advanced element
891      *
892      * @var array
893      */
894     var $_advancedElements = array();
896     /**
897      * Whether to display advanced elements (on page load)
898      *
899      * @var boolean
900      */
901     var $_showAdvanced = null;
903     /**
904      * The form name is derrived from the class name of the wrapper minus the trailing form
905      * It is a name with words joined by underscores whereas the id attribute is words joined by
906      * underscores.
907      *
908      * @var unknown_type
909      */
910     var $_formName = '';
912     /**
913      * String with the html for hidden params passed in as part of a moodle_url object for the action. Output in the form.
914      *
915      * @var string
916      */
917     var $_pageparams = '';
919     /**
920      * Class constructor - same parameters as HTML_QuickForm_DHTMLRulesTableless
921      * @param    string      $formName          Form's name.
922      * @param    string      $method            (optional)Form's method defaults to 'POST'
923      * @param    mixed      $action             (optional)Form's action - string or moodle_url
924      * @param    string      $target            (optional)Form's target defaults to none
925      * @param    mixed       $attributes        (optional)Extra attributes for <form> tag
926      * @param    bool        $trackSubmit       (optional)Whether to track if the form was submitted by adding a special hidden field
927      * @access   public
928      */
929     function MoodleQuickForm($formName, $method, $action, $target='', $attributes=null){
930         global $CFG;
932         static $formcounter = 1;
934         HTML_Common::HTML_Common($attributes);
935         $target = empty($target) ? array() : array('target' => $target);
936         $this->_formName = $formName;
937         if (is_a($action, 'moodle_url')){
938             $this->_pageparams = $action->hidden_params_out();
939             $action = $action->out(true);
940         } else {
941             $this->_pageparams = '';
942         }
943         //no 'name' atttribute for form in xhtml strict :
944         $attributes = array('action'=>$action, 'method'=>$method, 'id'=>'mform'.$formcounter) + $target;
945         $formcounter++;
946         $this->updateAttributes($attributes);
948         //this is custom stuff for Moodle :
949         $oldclass=   $this->getAttribute('class');
950         if (!empty($oldclass)){
951             $this->updateAttributes(array('class'=>$oldclass.' mform'));
952         }else {
953             $this->updateAttributes(array('class'=>'mform'));
954         }
955         $this->_reqHTML = '<img class="req" title="'.get_string('requiredelement', 'form').'" alt="'.get_string('requiredelement', 'form').'" src="'.$CFG->pixpath.'/req.gif'.'" />';
956         $this->_advancedHTML = '<img class="adv" title="'.get_string('advancedelement', 'form').'" alt="'.get_string('advancedelement', 'form').'" src="'.$CFG->pixpath.'/adv.gif'.'" />';
957         $this->setRequiredNote(get_string('somefieldsrequired', 'form', '<img alt="'.get_string('requiredelement', 'form').'" src="'.$CFG->pixpath.'/req.gif'.'" />'));
958         //(Help file doesn't add anything) helpbutton('requiredelement', get_string('requiredelement', 'form'), 'moodle', true, false, '', true));
959     }
961     /**
962      * Use this method to indicate an element in a form is an advanced field. If items in a form
963      * are marked as advanced then 'Hide/Show Advanced' buttons will automatically be displayed in the
964      * form so the user can decide whether to display advanced form controls.
965      *
966      * If you set a header element to advanced then all elements it contains will also be set as advanced.
967      *
968      * @param string $elementName group or element name (not the element name of something inside a group).
969      * @param boolean $advanced default true sets the element to advanced. False removes advanced mark.
970      */
971     function setAdvanced($elementName, $advanced=true){
972         if ($advanced){
973             $this->_advancedElements[$elementName]='';
974         } elseif (isset($this->_advancedElements[$elementName])) {
975             unset($this->_advancedElements[$elementName]);
976         }
977         if ($advanced && $this->getElementType('mform_showadvanced_last')===false){
978             $this->setShowAdvanced();
979             $this->registerNoSubmitButton('mform_showadvanced');
981             $this->addElement('hidden', 'mform_showadvanced_last');
982         }
983     }
984     /**
985      * Set whether to show advanced elements in the form on first displaying form. Default is not to
986      * display advanced elements in the form until 'Show Advanced' is pressed.
987      *
988      * You can get the last state of the form and possibly save it for this user by using
989      * value 'mform_showadvanced_last' in submitted data.
990      *
991      * @param boolean $showadvancedNow
992      */
993     function setShowAdvanced($showadvancedNow = null){
994         if ($showadvancedNow === null){
995             if ($this->_showAdvanced !== null){
996                 return;
997             } else { //if setShowAdvanced is called without any preference
998                      //make the default to not show advanced elements.
999                 $showadvancedNow = get_user_preferences(
1000                                 moodle_strtolower($this->_formName.'_showadvanced', 0));
1001             }
1002         }
1003         //value of hidden element
1004         $hiddenLast = optional_param('mform_showadvanced_last', -1, PARAM_INT);
1005         //value of button
1006         $buttonPressed = optional_param('mform_showadvanced', 0, PARAM_RAW);
1007         //toggle if button pressed or else stay the same
1008         if ($hiddenLast == -1) {
1009             $next = $showadvancedNow;
1010         } elseif ($buttonPressed) { //toggle on button press
1011             $next = !$hiddenLast;
1012         } else {
1013             $next = $hiddenLast;
1014         }
1015         $this->_showAdvanced = $next;
1016         if ($showadvancedNow != $next){
1017             set_user_preference($this->_formName.'_showadvanced', $next);
1018         }
1019         $this->setConstants(array('mform_showadvanced_last'=>$next));
1020     }
1021     function getShowAdvanced(){
1022         return $this->_showAdvanced;
1023     }
1026    /**
1027     * Accepts a renderer
1028     *
1029     * @param HTML_QuickForm_Renderer  An HTML_QuickForm_Renderer object
1030     * @since 3.0
1031     * @access public
1032     * @return void
1033     */
1034     function accept(&$renderer) {
1035         if (method_exists($renderer, 'setAdvancedElements')){
1036             //check for visible fieldsets where all elements are advanced
1037             //and mark these headers as advanced as well.
1038             //And mark all elements in a advanced header as advanced
1039             $stopFields = $renderer->getStopFieldSetElements();
1040             $lastHeader = null;
1041             $lastHeaderAdvanced = false;
1042             $anyAdvanced = false;
1043             foreach (array_keys($this->_elements) as $elementIndex){
1044                 $element =& $this->_elements[$elementIndex];
1046                 // if closing header and any contained element was advanced then mark it as advanced
1047                 if ($element->getType()=='header' || in_array($element->getName(), $stopFields)){
1048                     if ($anyAdvanced && !is_null($lastHeader)){
1049                         $this->setAdvanced($lastHeader->getName());
1050                     }
1051                     $lastHeaderAdvanced = false;
1052                     unset($lastHeader);
1053                     $lastHeader = null;
1054                 } elseif ($lastHeaderAdvanced) {
1055                     $this->setAdvanced($element->getName());
1056                 }
1058                 if ($element->getType()=='header'){
1059                     $lastHeader =& $element;
1060                     $anyAdvanced = false;
1061                     $lastHeaderAdvanced = isset($this->_advancedElements[$element->getName()]);
1062                 } elseif (isset($this->_advancedElements[$element->getName()])){
1063                     $anyAdvanced = true;
1064                 }
1065             }
1066             // the last header may not be closed yet...
1067             if ($anyAdvanced && !is_null($lastHeader)){
1068                 $this->setAdvanced($lastHeader->getName());
1069             }
1070             $renderer->setAdvancedElements($this->_advancedElements);
1072         }
1073         parent::accept($renderer);
1074     }
1078     function closeHeaderBefore($elementName){
1079         $renderer =& $this->defaultRenderer();
1080         $renderer->addStopFieldsetElements($elementName);
1081     }
1083     /**
1084      * Should be used for all elements of a form except for select, radio and checkboxes which
1085      * clean their own data.
1086      *
1087      * @param string $elementname
1088      * @param integer $paramtype use the constants PARAM_*.
1089      *     *  PARAM_CLEAN is deprecated and you should try to use a more specific type.
1090      *     *  PARAM_TEXT should be used for cleaning data that is expected to be plain text.
1091      *          It will strip all html tags. But will still let tags for multilang support
1092      *          through.
1093      *     *  PARAM_RAW means no cleaning whatsoever, it is used mostly for data from the
1094      *          html editor. Data from the editor is later cleaned before display using
1095      *          format_text() function. PARAM_RAW can also be used for data that is validated
1096      *          by some other way or printed by p() or s().
1097      *     *  PARAM_INT should be used for integers.
1098      *     *  PARAM_ACTION is an alias of PARAM_ALPHA and is used for hidden fields specifying
1099      *          form actions.
1100      */
1101     function setType($elementname, $paramtype) {
1102         $this->_types[$elementname] = $paramtype;
1103     }
1105     /**
1106      * See description of setType above. This can be used to set several types at once.
1107      *
1108      * @param array $paramtypes
1109      */
1110     function setTypes($paramtypes) {
1111         $this->_types = $paramtypes + $this->_types;
1112     }
1114     function updateSubmission($submission, $files) {
1115         $this->_flagSubmitted = false;
1117         if (empty($submission)) {
1118             $this->_submitValues = array();
1119         } else {
1120             foreach ($submission as $key=>$s) {
1121                 if (array_key_exists($key, $this->_types)) {
1122                     $submission[$key] = clean_param($s, $this->_types[$key]);
1123                 }
1124             }
1125             $this->_submitValues = $submission;
1126             $this->_flagSubmitted = true;
1127         }
1129         if (empty($files)) {
1130             $this->_submitFiles = array();
1131         } else {
1132             $this->_submitFiles = $files;
1133             $this->_flagSubmitted = true;
1134         }
1136         // need to tell all elements that they need to update their value attribute.
1137          foreach (array_keys($this->_elements) as $key) {
1138              $this->_elements[$key]->onQuickFormEvent('updateValue', null, $this);
1139          }
1140     }
1142     function getReqHTML(){
1143         return $this->_reqHTML;
1144     }
1146     function getAdvancedHTML(){
1147         return $this->_advancedHTML;
1148     }
1150     /**
1151      * Initializes a default form value. Used to specify the default for a new entry where
1152      * no data is loaded in using moodleform::set_data()
1153      *
1154      * note: $slashed param removed
1155      *
1156      * @param     string   $elementname        element name
1157      * @param     mixed    $values             values for that element name
1158      * @access    public
1159      * @return    void
1160      */
1161     function setDefault($elementName, $defaultValue){
1162         $this->setDefaults(array($elementName=>$defaultValue));
1163     } // end func setDefault
1164     /**
1165      * Add an array of buttons to the form
1166      * @param    array       $buttons          An associative array representing help button to attach to
1167      *                                          to the form. keys of array correspond to names of elements in form.
1168      *
1169      * @access   public
1170     */
1171     function setHelpButtons($buttons, $suppresscheck=false, $function='helpbutton'){
1173         foreach ($buttons as $elementname => $button){
1174             $this->setHelpButton($elementname, $button, $suppresscheck, $function);
1175         }
1176     }
1177     /**
1178      * Add a single button.
1179      *
1180      * @param string $elementname name of the element to add the item to
1181      * @param array $button - arguments to pass to function $function
1182      * @param boolean $suppresscheck - whether to throw an error if the element
1183      *                                  doesn't exist.
1184      * @param string $function - function to generate html from the arguments in $button
1185      */
1186     function setHelpButton($elementname, $button, $suppresscheck=false, $function='helpbutton'){
1187         if (array_key_exists($elementname, $this->_elementIndex)){
1188             //_elements has a numeric index, this code accesses the elements by name
1189             $element=&$this->_elements[$this->_elementIndex[$elementname]];
1190             if (method_exists($element, 'setHelpButton')){
1191                 $element->setHelpButton($button, $function);
1192             }else{
1193                 $a=new object();
1194                 $a->name=$element->getName();
1195                 $a->classname=get_class($element);
1196                 print_error('nomethodforaddinghelpbutton', 'form', '', $a);
1197             }
1198         }elseif (!$suppresscheck){
1199             print_error('nonexistentformelements', 'form', '', $elementname);
1200         }
1201     }
1203     function exportValues($elementList = null){
1204         $unfiltered = array();
1205         if (null === $elementList) {
1206             // iterate over all elements, calling their exportValue() methods
1207             $emptyarray = array();
1208             foreach (array_keys($this->_elements) as $key) {
1209                 if ($this->_elements[$key]->isFrozen() && !$this->_elements[$key]->_persistantFreeze){
1210                     $value = $this->_elements[$key]->exportValue($emptyarray, true);
1211                 } else {
1212                     $value = $this->_elements[$key]->exportValue($this->_submitValues, true);
1213                 }
1215                 if (is_array($value)) {
1216                     // This shit throws a bogus warning in PHP 4.3.x
1217                     $unfiltered = HTML_QuickForm::arrayMerge($unfiltered, $value);
1218                 }
1219             }
1220         } else {
1221             if (!is_array($elementList)) {
1222                 $elementList = array_map('trim', explode(',', $elementList));
1223             }
1224             foreach ($elementList as $elementName) {
1225                 $value = $this->exportValue($elementName);
1226                 if (PEAR::isError($value)) {
1227                     return $value;
1228                 }
1229                 $unfiltered[$elementName] = $value;
1230             }
1231         }
1233         return $unfiltered;
1234     }
1235     /**
1236      * Adds a validation rule for the given field
1237      *
1238      * If the element is in fact a group, it will be considered as a whole.
1239      * To validate grouped elements as separated entities,
1240      * use addGroupRule instead of addRule.
1241      *
1242      * @param    string     $element       Form element name
1243      * @param    string     $message       Message to display for invalid data
1244      * @param    string     $type          Rule type, use getRegisteredRules() to get types
1245      * @param    string     $format        (optional)Required for extra rule data
1246      * @param    string     $validation    (optional)Where to perform validation: "server", "client"
1247      * @param    boolean    $reset         Client-side validation: reset the form element to its original value if there is an error?
1248      * @param    boolean    $force         Force the rule to be applied, even if the target form element does not exist
1249      * @since    1.0
1250      * @access   public
1251      * @throws   HTML_QuickForm_Error
1252      */
1253     function addRule($element, $message, $type, $format=null, $validation='server', $reset = false, $force = false)
1254     {
1255         parent::addRule($element, $message, $type, $format, $validation, $reset, $force);
1256         if ($validation == 'client') {
1257             $this->updateAttributes(array('onsubmit' => 'try { var myValidator = validate_' . $this->_formName . '; } catch(e) { return true; } return myValidator(this);'));
1258         }
1260     } // end func addRule
1261     /**
1262      * Adds a validation rule for the given group of elements
1263      *
1264      * Only groups with a name can be assigned a validation rule
1265      * Use addGroupRule when you need to validate elements inside the group.
1266      * Use addRule if you need to validate the group as a whole. In this case,
1267      * the same rule will be applied to all elements in the group.
1268      * Use addRule if you need to validate the group against a function.
1269      *
1270      * @param    string     $group         Form group name
1271      * @param    mixed      $arg1          Array for multiple elements or error message string for one element
1272      * @param    string     $type          (optional)Rule type use getRegisteredRules() to get types
1273      * @param    string     $format        (optional)Required for extra rule data
1274      * @param    int        $howmany       (optional)How many valid elements should be in the group
1275      * @param    string     $validation    (optional)Where to perform validation: "server", "client"
1276      * @param    bool       $reset         Client-side: whether to reset the element's value to its original state if validation failed.
1277      * @since    2.5
1278      * @access   public
1279      * @throws   HTML_QuickForm_Error
1280      */
1281     function addGroupRule($group, $arg1, $type='', $format=null, $howmany=0, $validation = 'server', $reset = false)
1282     {
1283         parent::addGroupRule($group, $arg1, $type, $format, $howmany, $validation, $reset);
1284         if (is_array($arg1)) {
1285              foreach ($arg1 as $rules) {
1286                 foreach ($rules as $rule) {
1287                     $validation = (isset($rule[3]) && 'client' == $rule[3])? 'client': 'server';
1289                     if ('client' == $validation) {
1290                         $this->updateAttributes(array('onsubmit' => 'try { var myValidator = validate_' . $this->_formName . '; } catch(e) { return true; } return myValidator(this);'));
1291                     }
1292                 }
1293             }
1294         } elseif (is_string($arg1)) {
1296             if ($validation == 'client') {
1297                 $this->updateAttributes(array('onsubmit' => 'try { var myValidator = validate_' . $this->_formName . '; } catch(e) { return true; } return myValidator(this);'));
1298             }
1299         }
1300     } // end func addGroupRule
1302     // }}}
1303     /**
1304      * Returns the client side validation script
1305      *
1306      * The code here was copied from HTML_QuickForm_DHTMLRulesTableless who copied it from  HTML_QuickForm
1307      * and slightly modified to run rules per-element
1308      * Needed to override this because of an error with client side validation of grouped elements.
1309      *
1310      * @access    public
1311      * @return    string    Javascript to perform validation, empty string if no 'client' rules were added
1312      */
1313     function getValidationScript()
1314     {
1315         if (empty($this->_rules) || empty($this->_attributes['onsubmit'])) {
1316             return '';
1317         }
1319         include_once('HTML/QuickForm/RuleRegistry.php');
1320         $registry =& HTML_QuickForm_RuleRegistry::singleton();
1321         $test = array();
1322         $js_escape = array(
1323             "\r"    => '\r',
1324             "\n"    => '\n',
1325             "\t"    => '\t',
1326             "'"     => "\\'",
1327             '"'     => '\"',
1328             '\\'    => '\\\\'
1329         );
1331         foreach ($this->_rules as $elementName => $rules) {
1332             foreach ($rules as $rule) {
1333                 if ('client' == $rule['validation']) {
1334                     unset($element); //TODO: find out how to properly initialize it
1336                     $dependent  = isset($rule['dependent']) && is_array($rule['dependent']);
1337                     $rule['message'] = strtr($rule['message'], $js_escape);
1339                     if (isset($rule['group'])) {
1340                         $group    =& $this->getElement($rule['group']);
1341                         // No JavaScript validation for frozen elements
1342                         if ($group->isFrozen()) {
1343                             continue 2;
1344                         }
1345                         $elements =& $group->getElements();
1346                         foreach (array_keys($elements) as $key) {
1347                             if ($elementName == $group->getElementName($key)) {
1348                                 $element =& $elements[$key];
1349                                 break;
1350                             }
1351                         }
1352                     } elseif ($dependent) {
1353                         $element   =  array();
1354                         $element[] =& $this->getElement($elementName);
1355                         foreach ($rule['dependent'] as $elName) {
1356                             $element[] =& $this->getElement($elName);
1357                         }
1358                     } else {
1359                         $element =& $this->getElement($elementName);
1360                     }
1361                     // No JavaScript validation for frozen elements
1362                     if (is_object($element) && $element->isFrozen()) {
1363                         continue 2;
1364                     } elseif (is_array($element)) {
1365                         foreach (array_keys($element) as $key) {
1366                             if ($element[$key]->isFrozen()) {
1367                                 continue 3;
1368                             }
1369                         }
1370                     }
1371                     // Fix for bug displaying errors for elements in a group
1372                     //$test[$elementName][] = $registry->getValidationScript($element, $elementName, $rule);
1373                     $test[$elementName][0][] = $registry->getValidationScript($element, $elementName, $rule);
1374                     $test[$elementName][1]=$element;
1375                     //end of fix
1376                 }
1377             }
1378         }
1380         // Fix for MDL-9524. If you don't do this, then $element may be left as a reference to one of the fields in
1381         // the form, and then that form field gets corrupted by the code that follows.
1382         unset($element);
1384         $js = '
1385 <script type="text/javascript">
1386 //<![CDATA[
1388 var skipClientValidation = false;
1390 function qf_errorHandler(element, _qfMsg) {
1391   div = element.parentNode;
1392   if (_qfMsg != \'\') {
1393     var errorSpan = document.getElementById(\'id_error_\'+element.name);
1394     if (!errorSpan) {
1395       errorSpan = document.createElement("span");
1396       errorSpan.id = \'id_error_\'+element.name;
1397       errorSpan.className = "error";
1398       element.parentNode.insertBefore(errorSpan, element.parentNode.firstChild);
1399     }
1401     while (errorSpan.firstChild) {
1402       errorSpan.removeChild(errorSpan.firstChild);
1403     }
1405     errorSpan.appendChild(document.createTextNode(_qfMsg.substring(3)));
1406     errorSpan.appendChild(document.createElement("br"));
1408     if (div.className.substr(div.className.length - 6, 6) != " error"
1409         && div.className != "error") {
1410       div.className += " error";
1411     }
1413     return false;
1414   } else {
1415     var errorSpan = document.getElementById(\'id_error_\'+element.name);
1416     if (errorSpan) {
1417       errorSpan.parentNode.removeChild(errorSpan);
1418     }
1420     if (div.className.substr(div.className.length - 6, 6) == " error") {
1421       div.className = div.className.substr(0, div.className.length - 6);
1422     } else if (div.className == "error") {
1423       div.className = "";
1424     }
1426     return true;
1427   }
1428 }';
1429         $validateJS = '';
1430         foreach ($test as $elementName => $jsandelement) {
1431             // Fix for bug displaying errors for elements in a group
1432             //unset($element);
1433             list($jsArr,$element)=$jsandelement;
1434             //end of fix
1435             $js .= '
1436 function validate_' . $this->_formName . '_' . $elementName . '(element) {
1437   var value = \'\';
1438   var errFlag = new Array();
1439   var _qfGroups = {};
1440   var _qfMsg = \'\';
1441   var frm = element.parentNode;
1442   while (frm && frm.nodeName != "FORM") {
1443     frm = frm.parentNode;
1444   }
1445 ' . join("\n", $jsArr) . '
1446   return qf_errorHandler(element, _qfMsg);
1448 ';
1449             $validateJS .= '
1450   ret = validate_' . $this->_formName . '_' . $elementName.'(frm.elements[\''.$elementName.'\']) && ret;
1451   if (!ret && !first_focus) {
1452     first_focus = true;
1453     frm.elements[\''.$elementName.'\'].focus();
1454   }
1455 ';
1457             // Fix for bug displaying errors for elements in a group
1458             //unset($element);
1459             //$element =& $this->getElement($elementName);
1460             //end of fix
1461             $valFunc = 'validate_' . $this->_formName . '_' . $elementName . '(this)';
1462             $onBlur = $element->getAttribute('onBlur');
1463             $onChange = $element->getAttribute('onChange');
1464             $element->updateAttributes(array('onBlur' => $onBlur . $valFunc,
1465                                              'onChange' => $onChange . $valFunc));
1466         }
1467 //  do not rely on frm function parameter, because htmlarea breaks it when overloading the onsubmit method
1468         $js .= '
1469 function validate_' . $this->_formName . '(frm) {
1470   if (skipClientValidation) {
1471      return true;
1472   }
1473   var ret = true;
1475   var frm = document.getElementById(\''. $this->_attributes['id'] .'\')
1476   var first_focus = false;
1477 ' . $validateJS . ';
1478   return ret;
1480 //]]>
1481 </script>';
1482         return $js;
1483     } // end func getValidationScript
1484     function _setDefaultRuleMessages(){
1485         foreach ($this->_rules as $field => $rulesarr){
1486             foreach ($rulesarr as $key => $rule){
1487                 if ($rule['message']===null){
1488                     $a=new object();
1489                     $a->format=$rule['format'];
1490                     $str=get_string('err_'.$rule['type'], 'form', $a);
1491                     if (strpos($str, '[[')!==0){
1492                         $this->_rules[$field][$key]['message']=$str;
1493                     }
1494                 }
1495             }
1496         }
1497     }
1499     function getLockOptionEndScript(){
1501         $iname = $this->getAttribute('id').'items';
1502         $js = '<script type="text/javascript">'."\n";
1503         $js .= '//<![CDATA['."\n";
1504         $js .= "var $iname = Array();\n";
1506         foreach ($this->_dependencies as $dependentOn => $conditions){
1507             $js .= "{$iname}['$dependentOn'] = Array();\n";
1508             foreach ($conditions as $condition=>$values) {
1509                 $js .= "{$iname}['$dependentOn']['$condition'] = Array();\n";
1510                 foreach ($values as $value=>$dependents) {
1511                     $js .= "{$iname}['$dependentOn']['$condition']['$value'] = Array();\n";
1512                     $i = 0;
1513                     foreach ($dependents as $dependent) {
1514                         $elements = $this->_getElNamesRecursive($dependent);
1515                         if (empty($elements)) {
1516                             // probably element inside of some group
1517                             $elements = array($dependent);
1518                         }
1519                         foreach($elements as $element) {
1520                             if ($element == $dependentOn) {
1521                                 continue;
1522                             }
1523                             $js .= "{$iname}['$dependentOn']['$condition']['$value'][$i]='$element';\n";
1524                             $i++;
1525                         }
1526                     }
1527                 }
1528             }
1529         }
1530         $js .="lockoptionsallsetup('".$this->getAttribute('id')."');\n";
1531         $js .='//]]>'."\n";
1532         $js .='</script>'."\n";
1533         return $js;
1534     }
1536     function _getElNamesRecursive($element) {
1537         if (is_string($element)) {
1538             if (!$this->elementExists($element)) {
1539                 return array();
1540             }
1541             $element = $this->getElement($element);
1542         }
1544         if (is_a($element, 'HTML_QuickForm_group')) {
1545             $elsInGroup = $element->getElements();
1546             $elNames = array();
1547             foreach ($elsInGroup as $elInGroup){
1548                 if (is_a($elInGroup, 'HTML_QuickForm_group')) {
1549                     // not sure if this would work - groups nested in groups
1550                     $elNames = array_merge($elNames, $this->_getElNamesRecursive($elInGroup));
1551                 } else {
1552                     $elNames[] = $element->getElementName($elInGroup->getName());
1553                 }
1554             }
1556         } else if (is_a($element, 'HTML_QuickForm_header')) {
1557             return array();
1559         } else if (is_a($element, 'HTML_QuickForm_hidden')) {
1560             return array();
1562         } else if (method_exists($element, 'getPrivateName')) {
1563             return array($element->getPrivateName());
1565         } else {
1566             $elNames = array($element->getName());
1567         }
1569         return $elNames;
1570     }
1572     /**
1573      * Adds a dependency for $elementName which will be disabled if $condition is met.
1574      * If $condition = 'notchecked' (default) then the condition is that the $dependentOn element
1575      * is not checked. If $condition = 'checked' then the condition is that the $dependentOn element
1576      * is checked. If $condition is something else (like "eq" for equals) then it is checked to see if the value
1577      * of the $dependentOn element is $condition (such as equal) to $value.
1578      *
1579      * @param string $elementName the name of the element which will be disabled
1580      * @param string $dependentOn the name of the element whose state will be checked for
1581      *                            condition
1582      * @param string $condition the condition to check
1583      * @param mixed $value used in conjunction with condition.
1584      */
1585     function disabledIf($elementName, $dependentOn, $condition = 'notchecked', $value='1'){
1586         if (!array_key_exists($dependentOn, $this->_dependencies)) {
1587             $this->_dependencies[$dependentOn] = array();
1588         }
1589         if (!array_key_exists($condition, $this->_dependencies[$dependentOn])) {
1590             $this->_dependencies[$dependentOn][$condition] = array();
1591         }
1592         if (!array_key_exists($value, $this->_dependencies[$dependentOn][$condition])) {
1593             $this->_dependencies[$dependentOn][$condition][$value] = array();
1594         }
1595         $this->_dependencies[$dependentOn][$condition][$value][] = $elementName;
1596     }
1598     function registerNoSubmitButton($buttonname){
1599         $this->_noSubmitButtons[]=$buttonname;
1600     }
1602     function isNoSubmitButton($buttonname){
1603         return (array_search($buttonname, $this->_noSubmitButtons)!==FALSE);
1604     }
1606     function _registerCancelButton($addfieldsname){
1607         $this->_cancelButtons[]=$addfieldsname;
1608     }
1609     /**
1610      * Displays elements without HTML input tags.
1611      * This method is different to freeze() in that it makes sure no hidden
1612      * elements are included in the form. And a 'hardFrozen' element's submitted value is
1613      * ignored.
1614      *
1615      * This function also removes all previously defined rules.
1616      *
1617      * @param    mixed   $elementList       array or string of element(s) to be frozen
1618      * @since     1.0
1619      * @access   public
1620      * @throws   HTML_QuickForm_Error
1621      */
1622     function hardFreeze($elementList=null)
1623     {
1624         if (!isset($elementList)) {
1625             $this->_freezeAll = true;
1626             $elementList = array();
1627         } else {
1628             if (!is_array($elementList)) {
1629                 $elementList = preg_split('/[ ]*,[ ]*/', $elementList);
1630             }
1631             $elementList = array_flip($elementList);
1632         }
1634         foreach (array_keys($this->_elements) as $key) {
1635             $name = $this->_elements[$key]->getName();
1636             if ($this->_freezeAll || isset($elementList[$name])) {
1637                 $this->_elements[$key]->freeze();
1638                 $this->_elements[$key]->setPersistantFreeze(false);
1639                 unset($elementList[$name]);
1641                 // remove all rules
1642                 $this->_rules[$name] = array();
1643                 // if field is required, remove the rule
1644                 $unset = array_search($name, $this->_required);
1645                 if ($unset !== false) {
1646                     unset($this->_required[$unset]);
1647                 }
1648             }
1649         }
1651         if (!empty($elementList)) {
1652             return PEAR::raiseError(null, QUICKFORM_NONEXIST_ELEMENT, null, E_USER_WARNING, "Nonexistant element(s): '" . implode("', '", array_keys($elementList)) . "' in HTML_QuickForm::freeze()", 'HTML_QuickForm_Error', true);
1653         }
1654         return true;
1655     }
1656     /**
1657      * Hard freeze all elements in a form except those whose names are in $elementList or hidden elements in a form.
1658      *
1659      * This function also removes all previously defined rules of elements it freezes.
1660      *
1661      * @param    array   $elementList       array or string of element(s) not to be frozen
1662      * @since     1.0
1663      * @access   public
1664      * @throws   HTML_QuickForm_Error
1665      */
1666     function hardFreezeAllVisibleExcept($elementList)
1667     {
1668         $elementList = array_flip($elementList);
1669         foreach (array_keys($this->_elements) as $key) {
1670             $name = $this->_elements[$key]->getName();
1671             $type = $this->_elements[$key]->getType();
1673             if ($type == 'hidden'){
1674                 // leave hidden types as they are
1675             } elseif (!isset($elementList[$name])) {
1676                 $this->_elements[$key]->freeze();
1677                 $this->_elements[$key]->setPersistantFreeze(false);
1679                 // remove all rules
1680                 $this->_rules[$name] = array();
1681                 // if field is required, remove the rule
1682                 $unset = array_search($name, $this->_required);
1683                 if ($unset !== false) {
1684                     unset($this->_required[$unset]);
1685                 }
1686             }
1687         }
1688         return true;
1689     }
1690    /**
1691     * Tells whether the form was already submitted
1692     *
1693     * This is useful since the _submitFiles and _submitValues arrays
1694     * may be completely empty after the trackSubmit value is removed.
1695     *
1696     * @access public
1697     * @return bool
1698     */
1699     function isSubmitted()
1700     {
1701         return parent::isSubmitted() && (!$this->isFrozen());
1702     }
1706 /**
1707  * A renderer for MoodleQuickForm that only uses XHTML and CSS and no
1708  * table tags, extends PEAR class HTML_QuickForm_Renderer_Tableless
1709  *
1710  * Stylesheet is part of standard theme and should be automatically included.
1711  *
1712  * @author      Jamie Pratt <me@jamiep.org>
1713  * @license    gpl license
1714  */
1715 class MoodleQuickForm_Renderer extends HTML_QuickForm_Renderer_Tableless{
1717     /**
1718     * Element template array
1719     * @var      array
1720     * @access   private
1721     */
1722     var $_elementTemplates;
1723     /**
1724     * Template used when opening a hidden fieldset
1725     * (i.e. a fieldset that is opened when there is no header element)
1726     * @var      string
1727     * @access   private
1728     */
1729     var $_openHiddenFieldsetTemplate = "\n\t<fieldset class=\"hidden\"><div>";
1730    /**
1731     * Header Template string
1732     * @var      string
1733     * @access   private
1734     */
1735     var $_headerTemplate =
1736        "\n\t\t<legend class=\"ftoggler\">{header}</legend>\n\t\t<div class=\"advancedbutton\">{advancedimg}{button}</div><div class=\"fcontainer clearfix\">\n\t\t";
1738    /**
1739     * Template used when opening a fieldset
1740     * @var      string
1741     * @access   private
1742     */
1743     var $_openFieldsetTemplate = "\n\t<fieldset class=\"clearfix\" {id}>";
1745     /**
1746     * Template used when closing a fieldset
1747     * @var      string
1748     * @access   private
1749     */
1750     var $_closeFieldsetTemplate = "\n\t\t</div></fieldset>";
1752    /**
1753     * Required Note template string
1754     * @var      string
1755     * @access   private
1756     */
1757     var $_requiredNoteTemplate =
1758         "\n\t\t<div class=\"fdescription required\">{requiredNote}</div>";
1760     var $_advancedElements = array();
1762     /**
1763      * Whether to display advanced elements (on page load)
1764      *
1765      * @var integer 1 means show 0 means hide
1766      */
1767     var $_showAdvanced;
1769     function MoodleQuickForm_Renderer(){
1770         // switch next two lines for ol li containers for form items.
1771         //        $this->_elementTemplates=array('default'=>"\n\t\t".'<li class="fitem"><label>{label}{help}<!-- BEGIN required -->{req}<!-- END required --></label><div class="qfelement<!-- BEGIN error --> error<!-- END error --> {type}"><!-- BEGIN error --><span class="error">{error}</span><br /><!-- END error -->{element}</div></li>');
1772         $this->_elementTemplates = array(
1773         'default'=>"\n\t\t".'<div class="fitem {advanced}<!-- BEGIN required --> required<!-- END required -->"><div class="fitemtitle"><label>{label}<!-- BEGIN required -->{req}<!-- END required -->{advancedimg} {help}</label></div><div class="felement {type}<!-- BEGIN error --> error<!-- END error -->"><!-- BEGIN error --><span class="error">{error}</span><br /><!-- END error -->{element}</div></div>',
1775         'fieldset'=>"\n\t\t".'<div class="fitem {advanced}<!-- BEGIN required --> required<!-- END required -->"><div class="fitemtitle"><div class="fgrouplabel"><label>{label}<!-- BEGIN required -->{req}<!-- END required -->{advancedimg} {help}</label></div></div><fieldset class="felement {type}<!-- BEGIN error --> error<!-- END error -->"><!-- BEGIN error --><span class="error">{error}</span><br /><!-- END error -->{element}</fieldset></div>',
1777         'static'=>"\n\t\t".'<div class="fitem {advanced}"><div class="fitemtitle"><div class="fstaticlabel"><label>{label}<!-- BEGIN required -->{req}<!-- END required -->{advancedimg} {help}</label></div></div><div class="felement fstatic <!-- BEGIN error --> error<!-- END error -->"><!-- BEGIN error --><span class="error">{error}</span><br /><!-- END error -->{element}&nbsp;</div></div>',
1779         'nodisplay'=>'');
1781         parent::HTML_QuickForm_Renderer_Tableless();
1782     }
1784     function setAdvancedElements($elements){
1785         $this->_advancedElements = $elements;
1786     }
1788     /**
1789      * What to do when starting the form
1790      *
1791      * @param MoodleQuickForm $form
1792      */
1793     function startForm(&$form){
1794         $this->_reqHTML = $form->getReqHTML();
1795         $this->_elementTemplates = str_replace('{req}', $this->_reqHTML, $this->_elementTemplates);
1796         $this->_advancedHTML = $form->getAdvancedHTML();
1797         $this->_showAdvanced = $form->getShowAdvanced();
1798         parent::startForm($form);
1799         if ($form->isFrozen()){
1800             $this->_formTemplate = "\n<div class=\"mform frozen\">\n{content}\n</div>";
1801         } else {
1802             $this->_hiddenHtml .= $form->_pageparams;
1803         }
1806     }
1808     function startGroup(&$group, $required, $error){
1809         if (method_exists($group, 'getElementTemplateType')){
1810             $html = $this->_elementTemplates[$group->getElementTemplateType()];
1811         }else{
1812             $html = $this->_elementTemplates['default'];
1814         }
1815         if ($this->_showAdvanced){
1816             $advclass = ' advanced';
1817         } else {
1818             $advclass = ' advanced hide';
1819         }
1820         if (isset($this->_advancedElements[$group->getName()])){
1821             $html =str_replace(' {advanced}', $advclass, $html);
1822             $html =str_replace('{advancedimg}', $this->_advancedHTML, $html);
1823         } else {
1824             $html =str_replace(' {advanced}', '', $html);
1825             $html =str_replace('{advancedimg}', '', $html);
1826         }
1827         if (method_exists($group, 'getHelpButton')){
1828             $html =str_replace('{help}', $group->getHelpButton(), $html);
1829         }else{
1830             $html =str_replace('{help}', '', $html);
1831         }
1832         $html =str_replace('{name}', $group->getName(), $html);
1833         $html =str_replace('{type}', 'fgroup', $html);
1835         $this->_templates[$group->getName()]=$html;
1836         // Fix for bug in tableless quickforms that didn't allow you to stop a
1837         // fieldset before a group of elements.
1838         // if the element name indicates the end of a fieldset, close the fieldset
1839         if (   in_array($group->getName(), $this->_stopFieldsetElements)
1840             && $this->_fieldsetsOpen > 0
1841            ) {
1842             $this->_html .= $this->_closeFieldsetTemplate;
1843             $this->_fieldsetsOpen--;
1844         }
1845         parent::startGroup($group, $required, $error);
1846     }
1848     function renderElement(&$element, $required, $error){
1849         //manipulate id of all elements before rendering
1850         if (!is_null($element->getAttribute('id'))) {
1851             $id = $element->getAttribute('id');
1852         } else {
1853             $id = $element->getName();
1854         }
1855         //strip qf_ prefix and replace '[' with '_' and strip ']'
1856         $id = preg_replace(array('/^qf_|\]/', '/\[/'), array('', '_'), $id);
1857         if (strpos($id, 'id_') !== 0){
1858             $element->updateAttributes(array('id'=>'id_'.$id));
1859         }
1861         //adding stuff to place holders in template
1862         //check if this is a group element first
1863         if (($this->_inGroup) and !empty($this->_groupElementTemplate)) {
1864                 // so it gets substitutions for *each* element
1865             $html = $this->_groupTemplates[$element->getName()];        
1866         }
1867         elseif (method_exists($element, 'getElementTemplateType')){
1868             $html = $this->_elementTemplates[$element->getElementTemplateType()];
1869         }else{
1870             $html = $this->_elementTemplates['default'];
1871         }
1872         if ($this->_showAdvanced){
1873             $advclass = ' advanced';
1874         } else {
1875             $advclass = ' advanced hide';
1876         }
1877         if (isset($this->_advancedElements[$element->getName()])){
1878             $html =str_replace(' {advanced}', $advclass, $html);
1879         } else {
1880             $html =str_replace(' {advanced}', '', $html);
1881         }
1882         if (isset($this->_advancedElements[$element->getName()])||$element->getName() == 'mform_showadvanced'){
1883             $html =str_replace('{advancedimg}', $this->_advancedHTML, $html);
1884         } else {
1885             $html =str_replace('{advancedimg}', '', $html);
1886         }
1887         $html =str_replace('{type}', 'f'.$element->getType(), $html);
1888         $html =str_replace('{name}', $element->getName(), $html);
1889         if (method_exists($element, 'getHelpButton')){
1890             $html = str_replace('{help}', $element->getHelpButton(), $html);
1891         }else{
1892             $html = str_replace('{help}', '', $html);
1894         }
1895         if (($this->_inGroup) and !empty($this->_groupElementTemplate)) {
1896             $this->_groupElementTemplate = $html;
1897         }
1898         elseif (!isset($this->_templates[$element->getName()])) {
1899             $this->_templates[$element->getName()] = $html;
1900         }
1902         parent::renderElement($element, $required, $error);
1903     }
1905     function finishForm(&$form){
1906         if ($form->isFrozen()){
1907             $this->_hiddenHtml = '';
1908         }
1909         parent::finishForm($form);
1910         if ((!$form->isFrozen()) && ('' != ($script = $form->getLockOptionEndScript()))) {
1911             // add a lockoptions script
1912             $this->_html = $this->_html . "\n" . $script;
1913         }
1914     }
1915    /**
1916     * Called when visiting a header element
1917     *
1918     * @param    object     An HTML_QuickForm_header element being visited
1919     * @access   public
1920     * @return   void
1921     */
1922     function renderHeader(&$header)    {
1923         $name = $header->getName();
1925         $id = empty($name) ? '' : ' id="' . $name . '"';
1926         $id = preg_replace(array('/\]/', '/\[/'), array('', '_'), $id);
1927         if (is_null($header->_text)) {
1928             $header_html = '';
1929         } elseif (!empty($name) && isset($this->_templates[$name])) {
1930             $header_html = str_replace('{header}', $header->toHtml(), $this->_templates[$name]);
1931         } else {
1932             $header_html = str_replace('{header}', $header->toHtml(), $this->_headerTemplate);
1933         }
1935         if (isset($this->_advancedElements[$name])){
1936             $header_html =str_replace('{advancedimg}', $this->_advancedHTML, $header_html);
1937         } else {
1938             $header_html =str_replace('{advancedimg}', '', $header_html);
1939         }
1940         $elementName='mform_showadvanced';
1941         if ($this->_showAdvanced==0){
1942             $buttonlabel = get_string('showadvanced', 'form');
1943         } else {
1944             $buttonlabel = get_string('hideadvanced', 'form');
1945         }
1947         if (isset($this->_advancedElements[$name])){
1948             // this is tricky - the first submit button on form is "clicked" if user presses enter
1949             // we do not want to "submit" using advanced button if javascript active
1950             $showtext="'".get_string('showadvanced', 'form')."'";
1951             $hidetext="'".get_string('hideadvanced', 'form')."'";
1952             //onclick returns false so if js is on then page is not submitted.
1953             $onclick = 'return showAdvancedOnClick(this, '.$hidetext.', '.$showtext.');';
1954             $button_js = '<input name="'.$elementName.'" value="'.$buttonlabel.'" type="button" onclick="'.$onclick.'" />';
1955             $button_nojs = '<input name="'.$elementName.'" value="'.$buttonlabel.'" type="submit" />';
1956             $button = '<script type="text/javascript">
1957 //<![CDATA[
1958 document.write("'.addslashes_js($button_js).'")
1959 //]]>
1960 </script><noscript><div style="display:inline">'.$button_nojs.'</div></noscript>';  // the extra div should fix xhtml validation
1962             $header_html = str_replace('{button}', $button, $header_html);
1963         } else {
1964             $header_html = str_replace('{button}', '', $header_html);
1965         }
1967         if ($this->_fieldsetsOpen > 0) {
1968             $this->_html .= $this->_closeFieldsetTemplate;
1969             $this->_fieldsetsOpen--;
1970         }
1972         $openFieldsetTemplate = str_replace('{id}', $id, $this->_openFieldsetTemplate);
1973         if ($this->_showAdvanced){
1974             $advclass = ' class="advanced"';
1975         } else {
1976             $advclass = ' class="advanced hide"';
1977         }
1978         if (isset($this->_advancedElements[$name])){
1979             $openFieldsetTemplate = str_replace('{advancedclass}', $advclass, $openFieldsetTemplate);
1980         } else {
1981             $openFieldsetTemplate = str_replace('{advancedclass}', '', $openFieldsetTemplate);
1982         }
1983         $this->_html .= $openFieldsetTemplate . $header_html;
1984         $this->_fieldsetsOpen++;
1985     } // end func renderHeader
1987     function getStopFieldsetElements(){
1988         return $this->_stopFieldsetElements;
1989     }
1993 $GLOBALS['_HTML_QuickForm_default_renderer'] =& new MoodleQuickForm_Renderer();
1995 MoodleQuickForm::registerElementType('checkbox', "$CFG->libdir/form/checkbox.php", 'MoodleQuickForm_checkbox');
1996 MoodleQuickForm::registerElementType('file', "$CFG->libdir/form/file.php", 'MoodleQuickForm_file');
1997 MoodleQuickForm::registerElementType('filepicker', "$CFG->libdir/form/filepicker.php", 'MoodleQuickForm_filepicker');
1998 MoodleQuickForm::registerElementType('group', "$CFG->libdir/form/group.php", 'MoodleQuickForm_group');
1999 MoodleQuickForm::registerElementType('password', "$CFG->libdir/form/password.php", 'MoodleQuickForm_password');
2000 MoodleQuickForm::registerElementType('passwordunmask', "$CFG->libdir/form/passwordunmask.php", 'MoodleQuickForm_passwordunmask');
2001 MoodleQuickForm::registerElementType('radio', "$CFG->libdir/form/radio.php", 'MoodleQuickForm_radio');
2002 MoodleQuickForm::registerElementType('select', "$CFG->libdir/form/select.php", 'MoodleQuickForm_select');
2003 MoodleQuickForm::registerElementType('selectgroups', "$CFG->libdir/form/selectgroups.php", 'MoodleQuickForm_selectgroups');
2004 MoodleQuickForm::registerElementType('submitlink', "$CFG->libdir/form/submitlink.php", 'MoodleQuickForm_submitlink');
2005 MoodleQuickForm::registerElementType('text', "$CFG->libdir/form/text.php", 'MoodleQuickForm_text');
2006 MoodleQuickForm::registerElementType('textarea', "$CFG->libdir/form/textarea.php", 'MoodleQuickForm_textarea');
2007 MoodleQuickForm::registerElementType('date_selector', "$CFG->libdir/form/dateselector.php", 'MoodleQuickForm_date_selector');
2008 MoodleQuickForm::registerElementType('date_time_selector', "$CFG->libdir/form/datetimeselector.php", 'MoodleQuickForm_date_time_selector');
2009 MoodleQuickForm::registerElementType('htmleditor', "$CFG->libdir/form/htmleditor.php", 'MoodleQuickForm_htmleditor');
2010 MoodleQuickForm::registerElementType('format', "$CFG->libdir/form/format.php", 'MoodleQuickForm_format');
2011 MoodleQuickForm::registerElementType('static', "$CFG->libdir/form/static.php", 'MoodleQuickForm_static');
2012 MoodleQuickForm::registerElementType('hidden', "$CFG->libdir/form/hidden.php", 'MoodleQuickForm_hidden');
2013 MoodleQuickForm::registerElementType('modvisible', "$CFG->libdir/form/modvisible.php", 'MoodleQuickForm_modvisible');
2014 MoodleQuickForm::registerElementType('selectyesno', "$CFG->libdir/form/selectyesno.php", 'MoodleQuickForm_selectyesno');
2015 MoodleQuickForm::registerElementType('modgrade', "$CFG->libdir/form/modgrade.php", 'MoodleQuickForm_modgrade');
2016 MoodleQuickForm::registerElementType('cancel', "$CFG->libdir/form/cancel.php", 'MoodleQuickForm_cancel');
2017 MoodleQuickForm::registerElementType('button', "$CFG->libdir/form/button.php", 'MoodleQuickForm_button');
2018 MoodleQuickForm::registerElementType('choosecoursefile', "$CFG->libdir/form/choosecoursefile.php", 'MoodleQuickForm_choosecoursefile');
2019 MoodleQuickForm::registerElementType('choosecoursefileorimsrepo', "$CFG->libdir/form/choosecoursefileorimsrepo.php", 'MoodleQuickForm_choosecoursefileorimsrepo');
2020 MoodleQuickForm::registerElementType('header', "$CFG->libdir/form/header.php", 'MoodleQuickForm_header');
2021 MoodleQuickForm::registerElementType('submit', "$CFG->libdir/form/submit.php", 'MoodleQuickForm_submit');
2022 MoodleQuickForm::registerElementType('questioncategory', "$CFG->libdir/form/questioncategory.php", 'MoodleQuickForm_questioncategory');
2023 MoodleQuickForm::registerElementType('advcheckbox', "$CFG->libdir/form/advcheckbox.php", 'MoodleQuickForm_advcheckbox');
2024 MoodleQuickForm::registerElementType('recaptcha', "$CFG->libdir/form/recaptcha.php", 'MoodleQuickForm_recaptcha');
2025 ?>