Example #1
0
 /**
  * Called by HTML_QuickForm whenever form event is made on this element.
  *
  * @param string $event Name of event
  * @param mixed $arg event arguments
  * @param moodleform $caller calling object
  * @return mixed
  */
 public function onQuickFormEvent($event, $arg, &$caller)
 {
     switch ($event) {
         case 'createElement':
             // The first argument is the name.
             $name = $arg[0];
             // Set disable actions.
             $caller->disabledIf($name . '[modgrade_scale]', $name . '[modgrade_type]', 'neq', 'scale');
             $caller->disabledIf($name . '[modgrade_point]', $name . '[modgrade_type]', 'neq', 'point');
             // Set validation rules for the sub-elements belonging to this element.
             // A handy note: the parent scope of a closure is the function in which the closure was declared.
             // Because of this using $this is safe despite the closures being called statically.
             // A nasty magic hack!
             $checkmaxgrade = function ($val) {
                 // Closure to validate a max points value. See the note above about scope if this confuses you.
                 if (isset($val['modgrade_type']) && $val['modgrade_type'] === 'point') {
                     if (!isset($val['modgrade_point'])) {
                         return false;
                     }
                     return $this->validate_point($val['modgrade_point']);
                 }
                 return true;
             };
             $checkvalidscale = function ($val) {
                 // Closure to validate a scale value. See the note above about scope if this confuses you.
                 if (isset($val['modgrade_type']) && $val['modgrade_type'] === 'scale') {
                     if (!isset($val['modgrade_scale'])) {
                         return false;
                     }
                     return $this->validate_scale($val['modgrade_scale']);
                 }
                 return true;
             };
             $maxgradeexceeded = get_string('modgradeerrorbadpoint', 'grades', get_config('core', 'gradepointmax'));
             $invalidscale = get_string('modgradeerrorbadscale', 'grades');
             // When creating the rules the sixth arg is $force, we set it to true because otherwise the form
             // will attempt to validate the existence of the element, we don't want this because the element
             // is being created right now and doesn't actually exist as a registered element yet.
             $caller->addRule($name, $maxgradeexceeded, 'callback', $checkmaxgrade, 'server', false, true);
             $caller->addRule($name, $invalidscale, 'callback', $checkvalidscale, 'server', false, true);
             break;
         case 'updateValue':
             // As this is a group element with no value of its own we are only interested in situations where the
             // default value or a constant value are being provided to the actual element.
             // In this case we expect an int that is going to translate to a scale if negative, or to max points
             // if positive.
             // A constant value should be given as an int.
             // The default value should be an int and should really be $CFG->gradepointdefault.
             $value = $this->_findValue($caller->_constantValues);
             if (null === $value) {
                 if ($caller->isSubmitted()) {
                     break;
                 }
                 $value = $this->_findValue($caller->_defaultValues);
             }
             if (!is_null($value) && !is_scalar($value)) {
                 // Something unexpected (likely an array of subelement values) has been given - this will be dealt
                 // with somewhere else - where exactly... likely the subelements.
                 debugging('An invalid value (type ' . gettype($value) . ') has arrived at ' . __METHOD__, DEBUG_DEVELOPER);
                 break;
             }
             // Set element state for existing data.
             // This is really a pretty hacky thing to do, when data is being set the group element is called
             // with the data first and the subelements called afterwards.
             // This means that the subelements data (inc const and default values) can be overridden by form code.
             // So - when we call this code really we can't be sure that will be the end value for the element.
             if (!empty($this->_elements)) {
                 if (!empty($value)) {
                     if ($value < 0) {
                         $this->_elements[1]->setValue('scale');
                         $this->_elements[4]->setValue($value * -1);
                     } else {
                         if ($value > 0) {
                             $this->_elements[1]->setValue('point');
                             $this->_elements[7]->setValue($value);
                         }
                     }
                 } else {
                     $this->_elements[1]->setValue('none');
                     $this->_elements[7]->setValue('');
                 }
             }
             break;
     }
     // Always let the parent do its thing!
     return parent::onQuickFormEvent($event, $arg, $caller);
 }
Example #2
0
 /**
  * Called by HTML_QuickForm whenever form event is made on this element.
  *
  * @param string $event Name of event
  * @param mixed $arg event arguments
  * @param moodleform $caller calling object
  * @return mixed
  */
 public function onQuickFormEvent($event, $arg, &$caller)
 {
     switch ($event) {
         case 'createElement':
             // The first argument is the name.
             $name = $arg[0];
             // Set disable actions.
             $caller->disabledIf($name . '[modgrade_scale]', $name . '[modgrade_type]', 'neq', 'scale');
             $caller->disabledIf($name . '[modgrade_point]', $name . '[modgrade_type]', 'neq', 'point');
             $caller->disabledIf($name . '[modgrade_rescalegrades]', $name . '[modgrade_type]', 'neq', 'point');
             // Set validation rules for the sub-elements belonging to this element.
             // A handy note: the parent scope of a closure is the function in which the closure was declared.
             // Because of this using $this is safe despite the closures being called statically.
             // A nasty magic hack!
             $checkgradetypechange = function ($val) {
                 // Nothing is affected by changes to the grade type if there are no grades yet.
                 if (!$this->hasgrades) {
                     return true;
                 }
                 // Check if we are changing the grade type when grades are present.
                 if (isset($val['modgrade_type']) && $val['modgrade_type'] !== $this->currentgradetype) {
                     return false;
                 }
                 return true;
             };
             $checkscalechange = function ($val) {
                 // Nothing is affected by changes to the scale if there are no grades yet.
                 if (!$this->hasgrades) {
                     return true;
                 }
                 // Check if we are changing the scale type when grades are present.
                 // If modgrade_type is empty then use currentgradetype.
                 $gradetype = isset($val['modgrade_type']) ? $val['modgrade_type'] : $this->currentgradetype;
                 if ($gradetype === 'scale') {
                     if (isset($val['modgrade_scale']) && $val['modgrade_scale'] !== $this->currentscaleid) {
                         return false;
                     }
                 }
                 return true;
             };
             $checkmaxgradechange = function ($val) {
                 // Nothing is affected by changes to the max grade if there are no grades yet.
                 if (!$this->hasgrades) {
                     return true;
                 }
                 // If we are not using ratings we can change the max grade.
                 if (!$this->useratings) {
                     return true;
                 }
                 // Check if we are changing the max grade if we are using ratings and there is a grade.
                 // If modgrade_type is empty then use currentgradetype.
                 $gradetype = isset($val['modgrade_type']) ? $val['modgrade_type'] : $this->currentgradetype;
                 if ($gradetype === 'point') {
                     if (isset($val['modgrade_point']) && grade_floats_different($this->currentgrade, $val['modgrade_point'])) {
                         return false;
                     }
                 }
                 return true;
             };
             $checkmaxgrade = function ($val) {
                 // Closure to validate a max points value. See the note above about scope if this confuses you.
                 // If modgrade_type is empty then use currentgradetype.
                 $gradetype = isset($val['modgrade_type']) ? $val['modgrade_type'] : $this->currentgradetype;
                 if ($gradetype === 'point') {
                     if (isset($val['modgrade_point'])) {
                         return $this->validate_point($val['modgrade_point']);
                     }
                 }
                 return true;
             };
             $checkvalidscale = function ($val) {
                 // Closure to validate a scale value. See the note above about scope if this confuses you.
                 // If modgrade_type is empty then use currentgradetype.
                 $gradetype = isset($val['modgrade_type']) ? $val['modgrade_type'] : $this->currentgradetype;
                 if ($gradetype === 'scale') {
                     if (isset($val['modgrade_scale'])) {
                         return $this->validate_scale($val['modgrade_scale']);
                     }
                 }
                 return true;
             };
             $checkrescale = function ($val) {
                 // Nothing is affected by changes to grademax if there are no grades yet.
                 if (!$this->isupdate || !$this->hasgrades || !$this->canrescale) {
                     return true;
                 }
                 // Closure to validate a scale value. See the note above about scope if this confuses you.
                 // If modgrade_type is empty then use currentgradetype.
                 $gradetype = isset($val['modgrade_type']) ? $val['modgrade_type'] : $this->currentgradetype;
                 if ($gradetype === 'point' && isset($val['modgrade_point'])) {
                     // Work out if the value was actually changed in the form.
                     if (grade_floats_different($this->currentgrade, $val['modgrade_point'])) {
                         if (empty($val['modgrade_rescalegrades'])) {
                             // This was an "edit", the grademax was changed and the process existing setting was not set.
                             return false;
                         }
                     }
                 }
                 return true;
             };
             $cantchangegradetype = get_string('modgradecantchangegradetype', 'grades');
             $cantchangemaxgrade = get_string('modgradecantchangeratingmaxgrade', 'grades');
             $maxgradeexceeded = get_string('modgradeerrorbadpoint', 'grades', get_config('core', 'gradepointmax'));
             $invalidscale = get_string('modgradeerrorbadscale', 'grades');
             $cantchangescale = get_string('modgradecantchangescale', 'grades');
             $mustchooserescale = get_string('mustchooserescaleyesorno', 'grades');
             // When creating the rules the sixth arg is $force, we set it to true because otherwise the form
             // will attempt to validate the existence of the element, we don't want this because the element
             // is being created right now and doesn't actually exist as a registered element yet.
             $caller->addRule($name, $cantchangegradetype, 'callback', $checkgradetypechange, 'server', false, true);
             $caller->addRule($name, $cantchangemaxgrade, 'callback', $checkmaxgradechange, 'server', false, true);
             $caller->addRule($name, $maxgradeexceeded, 'callback', $checkmaxgrade, 'server', false, true);
             $caller->addRule($name, $invalidscale, 'callback', $checkvalidscale, 'server', false, true);
             $caller->addRule($name, $cantchangescale, 'callback', $checkscalechange, 'server', false, true);
             $caller->addRule($name, $mustchooserescale, 'callback', $checkrescale, 'server', false, true);
             break;
         case 'updateValue':
             // As this is a group element with no value of its own we are only interested in situations where the
             // default value or a constant value are being provided to the actual element.
             // In this case we expect an int that is going to translate to a scale if negative, or to max points
             // if positive.
             // Set the maximum points field to disabled if the rescale option has not been chosen and there are grades.
             $caller->disabledIf($this->getName() . '[modgrade_point]', $this->getName() . '[modgrade_rescalegrades]', 'eq', '');
             // A constant value should be given as an int.
             // The default value should be an int and be either $CFG->gradepointdefault or whatever was set in set_data().
             $value = $this->_findValue($caller->_constantValues);
             if (null === $value) {
                 if ($caller->isSubmitted() && $this->_findValue($caller->_submitValues) !== null) {
                     // Submitted values are array, one value for each individual element in this group.
                     // When there is submitted data let parent::onQuickFormEvent() process it.
                     break;
                 }
                 $value = $this->_findValue($caller->_defaultValues);
             }
             if (!is_null($value) && !is_scalar($value)) {
                 // Something unexpected (likely an array of subelement values) has been given - this will be dealt
                 // with somewhere else - where exactly... likely the subelements.
                 debugging('An invalid value (type ' . gettype($value) . ') has arrived at ' . __METHOD__, DEBUG_DEVELOPER);
                 break;
             }
             // Set element state for existing data.
             // This is really a pretty hacky thing to do, when data is being set the group element is called
             // with the data first and the subelements called afterwards.
             // This means that the subelements data (inc const and default values) can be overridden by form code.
             // So - when we call this code really we can't be sure that will be the end value for the element.
             if (!empty($this->_elements)) {
                 if (!empty($value)) {
                     if ($value < 0) {
                         $this->gradetypeformelement->setValue('scale');
                         $this->scaleformelement->setValue($value * -1);
                     } else {
                         if ($value > 0) {
                             $this->gradetypeformelement->setValue('point');
                             $this->maxgradeformelement->setValue($value);
                         }
                     }
                 } else {
                     $this->gradetypeformelement->setValue('none');
                     $this->maxgradeformelement->setValue('');
                 }
             }
             break;
     }
     // Always let the parent do its thing!
     return parent::onQuickFormEvent($event, $arg, $caller);
 }