Merge branch 'MDL-70041-310' of git://github.com/mihailges/moodle into MOODLE_310_STABLE
[moodle.git] / question / type / essay / renderer.php
1 <?php
2 // This file is part of Moodle - http://moodle.org/
3 //
4 // Moodle is free software: you can redistribute it and/or modify
5 // it under the terms of the GNU General Public License as published by
6 // the Free Software Foundation, either version 3 of the License, or
7 // (at your option) any later version.
8 //
9 // Moodle is distributed in the hope that it will be useful,
10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 // GNU General Public License for more details.
13 //
14 // You should have received a copy of the GNU General Public License
15 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
17 /**
18  * Essay question renderer class.
19  *
20  * @package    qtype
21  * @subpackage essay
22  * @copyright  2009 The Open University
23  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
24  */
27 defined('MOODLE_INTERNAL') || die();
30 /**
31  * Generates the output for essay questions.
32  *
33  * @copyright  2009 The Open University
34  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
35  */
36 class qtype_essay_renderer extends qtype_renderer {
37     public function formulation_and_controls(question_attempt $qa,
38             question_display_options $options) {
40         $question = $qa->get_question();
41         $responseoutput = $question->get_format_renderer($this->page);
43         // Answer field.
44         $step = $qa->get_last_step_with_qt_var('answer');
46         if (!$step->has_qt_var('answer') && empty($options->readonly)) {
47             // Question has never been answered, fill it with response template.
48             $step = new question_attempt_step(array('answer' => $question->responsetemplate));
49         }
51         if (empty($options->readonly)) {
52             $answer = $responseoutput->response_area_input('answer', $qa,
53                     $step, $question->responsefieldlines, $options->context);
55         } else {
56             $answer = $responseoutput->response_area_read_only('answer', $qa,
57                     $step, $question->responsefieldlines, $options->context);
58         }
60         $files = '';
61         if ($question->attachments) {
62             if (empty($options->readonly)) {
63                 $files = $this->files_input($qa, $question->attachments, $options);
65             } else {
66                 $files = $this->files_read_only($qa, $options);
67             }
68         }
70         $result = '';
71         $result .= html_writer::tag('div', $question->format_questiontext($qa),
72                 array('class' => 'qtext'));
74         $result .= html_writer::start_tag('div', array('class' => 'ablock'));
75         $result .= html_writer::tag('div', $answer, array('class' => 'answer'));
76         $result .= html_writer::tag('div', $files, array('class' => 'attachments'));
77         $result .= html_writer::end_tag('div');
79         return $result;
80     }
82     /**
83      * Displays any attached files when the question is in read-only mode.
84      * @param question_attempt $qa the question attempt to display.
85      * @param question_display_options $options controls what should and should
86      *      not be displayed. Used to get the context.
87      */
88     public function files_read_only(question_attempt $qa, question_display_options $options) {
89         $files = $qa->get_last_qt_files('attachments', $options->context->id);
90         $output = array();
92         foreach ($files as $file) {
93             $output[] = html_writer::tag('p', html_writer::link($qa->get_response_file_url($file),
94                     $this->output->pix_icon(file_file_icon($file), get_mimetype_description($file),
95                     'moodle', array('class' => 'icon')) . ' ' . s($file->get_filename())));
96         }
97         return implode($output);
98     }
100     /**
101      * Displays the input control for when the student should upload a single file.
102      * @param question_attempt $qa the question attempt to display.
103      * @param int $numallowed the maximum number of attachments allowed. -1 = unlimited.
104      * @param question_display_options $options controls what should and should
105      *      not be displayed. Used to get the context.
106      */
107     public function files_input(question_attempt $qa, $numallowed,
108             question_display_options $options) {
109         global $CFG;
110         require_once($CFG->dirroot . '/lib/form/filemanager.php');
112         $pickeroptions = new stdClass();
113         $pickeroptions->mainfile = null;
114         $pickeroptions->maxfiles = $numallowed;
115         $pickeroptions->itemid = $qa->prepare_response_files_draft_itemid(
116                 'attachments', $options->context->id);
117         $pickeroptions->context = $options->context;
118         $pickeroptions->return_types = FILE_INTERNAL | FILE_CONTROLLED_LINK;
120         $pickeroptions->itemid = $qa->prepare_response_files_draft_itemid(
121                 'attachments', $options->context->id);
122         $pickeroptions->accepted_types = $qa->get_question()->filetypeslist;
124         $fm = new form_filemanager($pickeroptions);
125         $fm->options->maxbytes = $qa->get_question()->maxbytes;;
126         $filesrenderer = $this->page->get_renderer('core', 'files');
128         $text = '';
129         if (!empty($qa->get_question()->filetypeslist)) {
130             $text = html_writer::tag('p', get_string('acceptedfiletypes', 'qtype_essay'));
131             $filetypesutil = new \core_form\filetypes_util();
132             $filetypes = $qa->get_question()->filetypeslist;
133             $filetypedescriptions = $filetypesutil->describe_file_types($filetypes);
134             $text .= $this->render_from_template('core_form/filetypes-descriptions', $filetypedescriptions);
135         }
136         return $filesrenderer->render($fm). html_writer::empty_tag(
137                 'input', array('type' => 'hidden', 'name' => $qa->get_qt_field_name('attachments'),
138                 'value' => $pickeroptions->itemid)) . $text;
139     }
141     public function manual_comment(question_attempt $qa, question_display_options $options) {
142         if ($options->manualcomment != question_display_options::EDITABLE) {
143             return '';
144         }
146         $question = $qa->get_question();
147         return html_writer::nonempty_tag('div', $question->format_text(
148                 $question->graderinfo, $question->graderinfo, $qa, 'qtype_essay',
149                 'graderinfo', $question->id), array('class' => 'graderinfo'));
150     }
154 /**
155  * A base class to abstract out the differences between different type of
156  * response format.
157  *
158  * @copyright  2011 The Open University
159  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
160  */
161 abstract class qtype_essay_format_renderer_base extends plugin_renderer_base {
162     /**
163      * Render the students respone when the question is in read-only mode.
164      * @param string $name the variable name this input edits.
165      * @param question_attempt $qa the question attempt being display.
166      * @param question_attempt_step $step the current step.
167      * @param int $lines approximate size of input box to display.
168      * @param object $context the context teh output belongs to.
169      * @return string html to display the response.
170      */
171     public abstract function response_area_read_only($name, question_attempt $qa,
172             question_attempt_step $step, $lines, $context);
174     /**
175      * Render the students respone when the question is in read-only mode.
176      * @param string $name the variable name this input edits.
177      * @param question_attempt $qa the question attempt being display.
178      * @param question_attempt_step $step the current step.
179      * @param int $lines approximate size of input box to display.
180      * @param object $context the context teh output belongs to.
181      * @return string html to display the response for editing.
182      */
183     public abstract function response_area_input($name, question_attempt $qa,
184             question_attempt_step $step, $lines, $context);
186     /**
187      * @return string specific class name to add to the input element.
188      */
189     protected abstract function class_name();
192 /**
193  * An essay format renderer for essays where the student should not enter
194  * any inline response.
195  *
196  * @copyright  2013 Binghamton University
197  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
198  */
199 class qtype_essay_format_noinline_renderer extends plugin_renderer_base {
201     protected function class_name() {
202         return 'qtype_essay_noinline';
203     }
205     public function response_area_read_only($name, $qa, $step, $lines, $context) {
206         return '';
207     }
209     public function response_area_input($name, $qa, $step, $lines, $context) {
210         return '';
211     }
215 /**
216  * An essay format renderer for essays where the student should use the HTML
217  * editor without the file picker.
218  *
219  * @copyright  2011 The Open University
220  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
221  */
222 class qtype_essay_format_editor_renderer extends plugin_renderer_base {
223     protected function class_name() {
224         return 'qtype_essay_editor';
225     }
227     public function response_area_read_only($name, $qa, $step, $lines, $context) {
228         return html_writer::tag('div', $this->prepare_response($name, $qa, $step, $context),
229                 ['class' => $this->class_name() . ' qtype_essay_response readonly',
230                         'style' => 'min-height: ' . ($lines * 1.5) . 'em;']);
231         // Height $lines * 1.5 because that is a typical line-height on web pages.
232         // That seems to give results that look OK.
233     }
235     public function response_area_input($name, $qa, $step, $lines, $context) {
236         global $CFG;
237         require_once($CFG->dirroot . '/repository/lib.php');
239         $inputname = $qa->get_qt_field_name($name);
240         $responseformat = $step->get_qt_var($name . 'format');
241         $id = $inputname . '_id';
243         $editor = editors_get_preferred_editor($responseformat);
244         $strformats = format_text_menu();
245         $formats = $editor->get_supported_formats();
246         foreach ($formats as $fid) {
247             $formats[$fid] = $strformats[$fid];
248         }
250         list($draftitemid, $response) = $this->prepare_response_for_editing(
251                 $name, $step, $context);
253         $editor->set_text($response);
254         $editor->use_editor($id, $this->get_editor_options($context),
255                 $this->get_filepicker_options($context, $draftitemid));
257         $output = '';
258         $output .= html_writer::start_tag('div', array('class' =>
259                 $this->class_name() . ' qtype_essay_response'));
261         $output .= html_writer::tag('div', html_writer::tag('textarea', s($response),
262                 array('id' => $id, 'name' => $inputname, 'rows' => $lines, 'cols' => 60)));
264         $output .= html_writer::start_tag('div');
265         if (count($formats) == 1) {
266             reset($formats);
267             $output .= html_writer::empty_tag('input', array('type' => 'hidden',
268                     'name' => $inputname . 'format', 'value' => key($formats)));
270         } else {
271             $output .= html_writer::label(get_string('format'), 'menu' . $inputname . 'format', false);
272             $output .= ' ';
273             $output .= html_writer::select($formats, $inputname . 'format', $responseformat, '');
274         }
275         $output .= html_writer::end_tag('div');
277         $output .= $this->filepicker_html($inputname, $draftitemid);
279         $output .= html_writer::end_tag('div');
280         return $output;
281     }
283     /**
284      * Prepare the response for read-only display.
285      * @param string $name the variable name this input edits.
286      * @param question_attempt $qa the question attempt being display.
287      * @param question_attempt_step $step the current step.
288      * @param object $context the context the attempt belongs to.
289      * @return string the response prepared for display.
290      */
291     protected function prepare_response($name, question_attempt $qa,
292             question_attempt_step $step, $context) {
293         if (!$step->has_qt_var($name)) {
294             return '';
295         }
297         $formatoptions = new stdClass();
298         $formatoptions->para = false;
299         return format_text($step->get_qt_var($name), $step->get_qt_var($name . 'format'),
300                 $formatoptions);
301     }
303     /**
304      * Prepare the response for editing.
305      * @param string $name the variable name this input edits.
306      * @param question_attempt_step $step the current step.
307      * @param object $context the context the attempt belongs to.
308      * @return string the response prepared for display.
309      */
310     protected function prepare_response_for_editing($name,
311             question_attempt_step $step, $context) {
312         return array(0, $step->get_qt_var($name));
313     }
315     /**
316      * @param object $context the context the attempt belongs to.
317      * @return array options for the editor.
318      */
319     protected function get_editor_options($context) {
320         // Disable the text-editor autosave because quiz has it's own auto save function.
321         return array('context' => $context, 'autosave' => false);
322     }
324     /**
325      * @param object $context the context the attempt belongs to.
326      * @param int $draftitemid draft item id.
327      * @return array filepicker options for the editor.
328      */
329     protected function get_filepicker_options($context, $draftitemid) {
330         return array('return_types'  => FILE_INTERNAL | FILE_EXTERNAL);
331     }
333     /**
334      * @param string $inputname input field name.
335      * @param int $draftitemid draft file area itemid.
336      * @return string HTML for the filepicker, if used.
337      */
338     protected function filepicker_html($inputname, $draftitemid) {
339         return '';
340     }
344 /**
345  * An essay format renderer for essays where the student should use the HTML
346  * editor with the file picker.
347  *
348  * @copyright  2011 The Open University
349  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
350  */
351 class qtype_essay_format_editorfilepicker_renderer extends qtype_essay_format_editor_renderer {
352     protected function class_name() {
353         return 'qtype_essay_editorfilepicker';
354     }
356     protected function prepare_response($name, question_attempt $qa,
357             question_attempt_step $step, $context) {
358         if (!$step->has_qt_var($name)) {
359             return '';
360         }
362         $formatoptions = new stdClass();
363         $formatoptions->para = false;
364         $text = $qa->rewrite_response_pluginfile_urls($step->get_qt_var($name),
365                 $context->id, 'answer', $step);
366         return format_text($text, $step->get_qt_var($name . 'format'), $formatoptions);
367     }
369     protected function prepare_response_for_editing($name,
370             question_attempt_step $step, $context) {
371         return $step->prepare_response_files_draft_itemid_with_text(
372                 $name, $context->id, $step->get_qt_var($name));
373     }
375     /**
376      * Get editor options for question response text area.
377      * @param object $context the context the attempt belongs to.
378      * @return array options for the editor.
379      */
380     protected function get_editor_options($context) {
381         return question_utils::get_editor_options($context);
382     }
384     /**
385      * Get the options required to configure the filepicker for one of the editor
386      * toolbar buttons.
387      * @deprecated since 3.5
388      * @param mixed $acceptedtypes array of types of '*'.
389      * @param int $draftitemid the draft area item id.
390      * @param object $context the context.
391      * @return object the required options.
392      */
393     protected function specific_filepicker_options($acceptedtypes, $draftitemid, $context) {
394         debugging('qtype_essay_format_editorfilepicker_renderer::specific_filepicker_options() is deprecated, ' .
395             'use question_utils::specific_filepicker_options() instead.', DEBUG_DEVELOPER);
397         $filepickeroptions = new stdClass();
398         $filepickeroptions->accepted_types = $acceptedtypes;
399         $filepickeroptions->return_types = FILE_INTERNAL | FILE_EXTERNAL;
400         $filepickeroptions->context = $context;
401         $filepickeroptions->env = 'filepicker';
403         $options = initialise_filepicker($filepickeroptions);
404         $options->context = $context;
405         $options->client_id = uniqid();
406         $options->env = 'editor';
407         $options->itemid = $draftitemid;
409         return $options;
410     }
412     /**
413      * @param object $context the context the attempt belongs to.
414      * @param int $draftitemid draft item id.
415      * @return array filepicker options for the editor.
416      */
417     protected function get_filepicker_options($context, $draftitemid) {
418         return question_utils::get_filepicker_options($context, $draftitemid);
419     }
421     protected function filepicker_html($inputname, $draftitemid) {
422         $nonjspickerurl = new moodle_url('/repository/draftfiles_manager.php', array(
423             'action' => 'browse',
424             'env' => 'editor',
425             'itemid' => $draftitemid,
426             'subdirs' => false,
427             'maxfiles' => -1,
428             'sesskey' => sesskey(),
429         ));
431         return html_writer::empty_tag('input', array('type' => 'hidden',
432                 'name' => $inputname . ':itemid', 'value' => $draftitemid)) .
433                 html_writer::tag('noscript', html_writer::tag('div',
434                     html_writer::tag('object', '', array('type' => 'text/html',
435                         'data' => $nonjspickerurl, 'height' => 160, 'width' => 600,
436                         'style' => 'border: 1px solid #000;'))));
437     }
441 /**
442  * An essay format renderer for essays where the student should use a plain
443  * input box, but with a normal, proportional font.
444  *
445  * @copyright  2011 The Open University
446  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
447  */
448 class qtype_essay_format_plain_renderer extends plugin_renderer_base {
449     /**
450      * @return string the HTML for the textarea.
451      */
452     protected function textarea($response, $lines, $attributes) {
453         $attributes['class'] = $this->class_name() . ' qtype_essay_response';
454         $attributes['rows'] = $lines;
455         $attributes['cols'] = 60;
456         return html_writer::tag('textarea', s($response), $attributes);
457     }
459     protected function class_name() {
460         return 'qtype_essay_plain';
461     }
463     public function response_area_read_only($name, $qa, $step, $lines, $context) {
464         return $this->textarea($step->get_qt_var($name), $lines, array('readonly' => 'readonly'));
465     }
467     public function response_area_input($name, $qa, $step, $lines, $context) {
468         $inputname = $qa->get_qt_field_name($name);
469         return $this->textarea($step->get_qt_var($name), $lines, array('name' => $inputname)) .
470                 html_writer::empty_tag('input', array('type' => 'hidden',
471                     'name' => $inputname . 'format', 'value' => FORMAT_PLAIN));
472     }
476 /**
477  * An essay format renderer for essays where the student should use a plain
478  * input box with a monospaced font. You might use this, for example, for a
479  * question where the students should type computer code.
480  *
481  * @copyright  2011 The Open University
482  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
483  */
484 class qtype_essay_format_monospaced_renderer extends qtype_essay_format_plain_renderer {
485     protected function class_name() {
486         return 'qtype_essay_monospaced';
487     }