MDL-20636 Essay questions can now handle files in the HTML editor. #216
[moodle.git] / question / type / essay / renderer.php
1 <?php
3 // This file is part of Moodle - http://moodle.org/
4 //
5 // Moodle is free software: you can redistribute it and/or modify
6 // it under the terms of the GNU General Public License as published by
7 // the Free Software Foundation, either version 3 of the License, or
8 // (at your option) any later version.
9 //
10 // Moodle is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
18 /**
19  * Essay question renderer class.
20  *
21  * @package    qtype
22  * @subpackage essay
23  * @copyright  2009 The Open University
24  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
25  */
28 defined('MOODLE_INTERNAL') || die();
31 /**
32  * Generates the output for essay questions.
33  *
34  * @copyright  2009 The Open University
35  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
36  */
37 class qtype_essay_renderer extends qtype_renderer {
38     public function formulation_and_controls(question_attempt $qa,
39             question_display_options $options) {
41         $question = $qa->get_question();
42         $responseoutput = $question->get_format_renderer($this->page);
44         // Answer field.
45         $step = $qa->get_last_step_with_qt_var('answer');
46         if (empty($options->readonly)) {
47             $answer = $responseoutput->response_area_input('answer', $qa,
48                     $step, $question->responsefieldlines, $options->context);
50         } else {
51             $answer = $responseoutput->response_area_read_only('answer', $qa,
52                     $step, $question->responsefieldlines, $options->context);
53         }
55         $files = '';
56         if ($question->attachments) {
57             if (empty($options->readonly)) {
58                 $files = $this->files_input($qa, $question->attachments, $options);
60             } else {
61                 $files = $this->files_read_only($qa, $options);
62             }
63         }
65         $result = '';
66         $result .= html_writer::tag('div', $question->format_questiontext($qa),
67                 array('class' => 'qtext'));
69         $result .= html_writer::start_tag('div', array('class' => 'ablock'));
70         $result .= html_writer::tag('div', $answer, array('class' => 'answer'));
71         $result .= html_writer::tag('div', $files, array('class' => 'attachments'));
72         $result .= html_writer::end_tag('div');
74         return $result;
75     }
77     /**
78      * Displays any attached files when the question is in read-only mode.
79      * @param question_attempt $qa the question attempt to display.
80      * @param question_display_options $options controls what should and should
81      *      not be displayed. Used to get the context.
82      */
83     public function files_read_only(question_attempt $qa, question_display_options $options) {
84         $files = $qa->get_last_qt_files('attachments', $options->context->id);
85         $output = array();
87         foreach ($files as $file) {
88             $mimetype = $file->get_mimetype();
89             $output[] = html_writer::tag('p', html_writer::link($qa->get_response_file_url($file),
90                     $this->output->pix_icon(file_mimetype_icon($mimetype), $mimetype,
91                     'moodle', array('class' => 'icon')) . ' ' . s($file->get_filename())));
92         }
93         return implode($output);
94     }
96     /**
97      * Displays the input control for when the student should upload a single file.
98      * @param question_attempt $qa the question attempt to display.
99      * @param int $numallowed the maximum number of attachments allowed. -1 = unlimited.
100      * @param question_display_options $options controls what should and should
101      *      not be displayed. Used to get the context.
102      */
103     public function files_input(question_attempt $qa, $numallowed, question_display_options $options) {
104         global $CFG;
105         require_once($CFG->dirroot . '/lib/form/filemanager.php');
107         $pickeroptions = new stdClass();
108         $pickeroptions->mainfile = null;
109         $pickeroptions->maxfiles = $numallowed;
110         $pickeroptions->itemid = $qa->prepare_response_files_draft_itemid(
111                 'attachments', $options->context->id);
112         $pickeroptions->context = $options->context;
114         $pickeroptions->itemid = $qa->prepare_response_files_draft_itemid(
115                 'attachments', $options->context->id);
117         return form_filemanager_render($pickeroptions) . html_writer::empty_tag(
118                 'input', array('type' => 'hidden', 'name' => $qa->get_qt_field_name('attachments'),
119                 'value' => $pickeroptions->itemid));
120     }
122     public function manual_comment(question_attempt $qa, question_display_options $options) {
123         if ($options->manualcomment != question_display_options::EDITABLE) {
124             return '';
125         }
127         $question = $qa->get_question();
128         return html_writer::nonempty_tag('div', $question->format_text(
129                 $question->graderinfo, $question->graderinfo, $qa, 'qtype_essay',
130                 'graderinfo', $question->id), array('class' => 'graderinfo'));
131     }
135 /**
136  * A base class to abstract out the differences between different type of
137  * response format.
138  *
139  * @copyright  2011 The Open University
140  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
141  */
142 abstract class qtype_essay_format_renderer_base extends plugin_renderer_base {
143     /**
144      * Render the students respone when the question is in read-only mode.
145      * @param string $name the variable name this input edits.
146      * @param question_attempt $qa the question attempt being display.
147      * @param question_attempt_step $step the current step.
148      * @param int $lines approximate size of input box to display.
149      * @param object $context the context teh output belongs to.
150      * @return string html to display the response.
151      */
152     public abstract function response_area_read_only($name, question_attempt $qa,
153             question_attempt_step $step, $lines, $context);
155     /**
156      * Render the students respone when the question is in read-only mode.
157      * @param string $name the variable name this input edits.
158      * @param question_attempt $qa the question attempt being display.
159      * @param question_attempt_step $step the current step.
160      * @param int $lines approximate size of input box to display.
161      * @param object $context the context teh output belongs to.
162      * @return string html to display the response for editing.
163      */
164     public abstract function response_area_input($name, question_attempt $qa,
165             question_attempt_step $step, $lines, $context);
167     /**
168      * @return string specific class name to add to the input element.
169      */
170     protected abstract function class_name();
174 /**
175  * An essay format renderer for essays where the student should use the HTML
176  * editor without the file picker.
177  *
178  * @copyright  2011 The Open University
179  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
180  */
181 class qtype_essay_format_editor_renderer extends plugin_renderer_base {
182     protected function class_name() {
183         return 'qtype_essay_editor';
184     }
186     public function response_area_read_only($name, $qa, $step, $lines, $context) {
187         return html_writer::tag('div', $this->prepare_response($name, $qa, $step, $context),
188                 array('class' => $this->class_name() . ' qtype_essay_response'));
189     }
191     public function response_area_input($name, $qa, $step, $lines, $context) {
192         global $CFG, $PAGE;
193         require_once($CFG->dirroot.'/repository/lib.php');
195         $inputname = $qa->get_qt_field_name($name);
196         $responseformat = $step->get_qt_var($name . 'format');
197         $id = $inputname . '_id';
199         $editor = editors_get_preferred_editor($responseformat);
200         $strformats = format_text_menu();
201         $formats = $editor->get_supported_formats();
202         foreach ($formats as $fid) {
203             $formats[$fid] = $strformats[$fid];
204         }
206         list($draftitemid, $reponse) = $this->prepare_response_for_editing(
207                 $name, $step, $context);
209         $editor->use_editor($id, $this->get_editor_options($context),
210                 $this->get_filepicker_options($context, $draftitemid));
212         $output = '';
213         $output .= html_writer::start_tag('div', array('class' =>
214                 $this->class_name() . ' qtype_essay_response'));
216         $output .= html_writer::tag('div', html_writer::tag('textarea', s($reponse),
217                 array('id' => $id, 'name' => $inputname, 'rows' => $lines)));
219         $output .= html_writer::start_tag('div');
220         if (count($formats == 1)) {
221             reset($formats);
222             $output .= html_writer::empty_tag('input', array('type' => 'hidden',
223                     'name' => $inputname . 'format', 'value' => key($formats)));
225         } else {
226             $output .= html_writer::select($formats, $inputname . 'format', $responseformat, '');
227         }
228         $output .= html_writer::end_tag('div');
230         $output .= $this->filepicker_html($inputname, $draftitemid);
232         $output .= html_writer::end_tag('div');
233         return $output;
234     }
236     /**
237      * Prepare the response for read-only display.
238      * @param string $name the variable name this input edits.
239      * @param question_attempt $qa the question attempt being display.
240      * @param question_attempt_step $step the current step.
241      * @param object $context the context the attempt belongs to.
242      * @return string the response prepared for display.
243      */
244     protected function prepare_response($name, question_attempt $qa,
245             question_attempt_step $step, $context) {
246         if (!$step->has_qt_var($name)) {
247             return '';
248         }
250         $formatoptions = new stdClass();
251         $formatoptions->para = false;
252         return format_text($step->get_qt_var($name), $step->get_qt_var($name . 'format'),
253                 $formatoptions);
254     }
256     /**
257      * Prepare the response for editing.
258      * @param string $name the variable name this input edits.
259      * @param question_attempt_step $step the current step.
260      * @param object $context the context the attempt belongs to.
261      * @return string the response prepared for display.
262      */
263     protected function prepare_response_for_editing($name,
264             question_attempt_step $step, $context) {
265         return array(0, $step->get_qt_var($name));
266     }
268     /**
269      * @param object $context the context the attempt belongs to.
270      * @return array options for the editor.
271      */
272     protected function get_editor_options($context) {
273         return array('context' => $context);
274     }
276     /**
277      * @param object $context the context the attempt belongs to.
278      * @param int $draftitemid draft item id.
279      * @return array filepicker options for the editor.
280      */
281     protected function get_filepicker_options($context, $draftitemid) {
282         return array();
283     }
285     /**
286      * @param string $inputname input field name.
287      * @param int $draftitemid draft file area itemid.
288      * @return string HTML for the filepicker, if used.
289      */
290     protected function filepicker_html($inputname, $draftitemid) {
291         return '';
292     }
296 /**
297  * An essay format renderer for essays where the student should use the HTML
298  * editor with the file picker.
299  *
300  * @copyright  2011 The Open University
301  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
302  */
303 class qtype_essay_format_editorfilepicker_renderer extends qtype_essay_format_editor_renderer {
304     protected function class_name() {
305         return 'qtype_essay_editorfilepicker';
306     }
308     protected function prepare_response($name, question_attempt $qa,
309             question_attempt_step $step, $context) {
310         if (!$step->has_qt_var($name)) {
311             return '';
312         }
314         $formatoptions = new stdClass();
315         $formatoptions->para = false;
316         $text = $qa->rewrite_response_pluginfile_urls($step->get_qt_var($name),
317                 $context->id, 'answer', $step);
318         return format_text($text, $step->get_qt_var($name . 'format'), $formatoptions);
319     }
321     protected function prepare_response_for_editing($name,
322             question_attempt_step $step, $context) {
323         return $step->prepare_response_files_draft_itemid_with_text(
324                 $name, $context->id, $step->get_qt_var($name));
325     }
327     protected function get_editor_options($context) {
328         return array(
329             'subdirs' => 0,
330             'maxbytes' => 0,
331             'maxfiles' => -1,
332             'context' => $context,
333             'noclean' => 0,
334             'trusttext'=>0
335         );
336     }
338     /**
339      * Get the options required to configure the filepicker for one of the editor
340      * toolbar buttons.
341      * @param mixed $acceptedtypes array of types of '*'.
342      * @param int $draftitemid the draft area item id.
343      * @param object $context the context.
344      * @return object the required options.
345      */
346     protected function specific_filepicker_options($acceptedtypes, $draftitemid, $context) {
347         $filepickeroptions = new stdClass();
348         $filepickeroptions->accepted_types = $acceptedtypes;
349         $filepickeroptions->return_types = FILE_INTERNAL | FILE_EXTERNAL;
350         $filepickeroptions->context = $context;
351         $filepickeroptions->env = 'filepicker';
353         $options = initialise_filepicker($filepickeroptions);
354         $options->context = $context;
355         $options->client_id = uniqid();
356         $options->env = 'editor';
357         $options->itemid = $draftitemid;
359         return $options;
360     }
362     protected function get_filepicker_options($context, $draftitemid) {
363         global $CFG;
365         return array(
366             'image' => $this->specific_filepicker_options(array('image'),
367                             $draftitemid, $context),
368             'media' => $this->specific_filepicker_options(array('video', 'audio'),
369                             $draftitemid, $context),
370             'link'  => $this->specific_filepicker_options('*',
371                             $draftitemid, $context),
372         );
373     }
375     protected function filepicker_html($inputname, $draftitemid) {
376         $nonjspickerurl = new moodle_url('/repository/draftfiles_manager.php', array(
377             'action' => 'browse',
378             'env' => 'editor',
379             'itemid' => $draftitemid,
380             'subdirs' => false,
381             'maxfiles' => -1,
382             'sesskey' => sesskey(),
383         ));
385         return html_writer::empty_tag('input', array('type' => 'hidden',
386                 'name' => $inputname . ':itemid', 'value' => $draftitemid)) .
387                 html_writer::tag('noscript', html_writer::tag('div',
388                     html_writer::tag('object', '', array('type' => 'text/html',
389                         'data' => $nonjspickerurl, 'height' => 160, 'width' => 600,
390                         'style' => 'border: 1px solid #000;'))));
391     }
395 /**
396  * An essay format renderer for essays where the student should use a plain
397  * input box, but with a normal, proportional font.
398  *
399  * @copyright  2011 The Open University
400  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
401  */
402 class qtype_essay_format_plain_renderer extends plugin_renderer_base {
403     /**
404      * @return string the HTML for the textarea.
405      */
406     protected function textarea($response, $lines, $attributes) {
407         $attributes['class'] = $this->class_name() . ' qtype_essay_response';
408         $attributes['rows'] = $lines;
409         return html_writer::tag('textarea', s($response), $attributes);
410     }
412     protected function class_name() {
413         return 'qtype_essay_plain';
414     }
416     public function response_area_read_only($name, $qa, $step, $lines, $context) {
417         return $this->textarea($step->get_qt_var($name), $lines, array('readonly' => 'readonly'));
418     }
420     public function response_area_input($name, $qa, $step, $lines, $context) {
421         $inputname = $qa->get_qt_field_name($name);
422         return $this->textarea($step->get_qt_var($name), $lines, array('name' => $inputname)) .
423                 html_writer::empty_tag('input', array('type' => 'hidden',
424                     'name' => $inputname . 'format', 'value' => FORMAT_PLAIN));
425     }
429 /**
430  * An essay format renderer for essays where the student should use a plain
431  * input box with a monospaced font. You might use this, for example, for a
432  * question where the students should type computer code.
433  *
434  * @copyright  2011 The Open University
435  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
436  */
437 class qtype_essay_format_monospaced_renderer extends qtype_essay_format_plain_renderer {
438     protected function class_name() {
439         return 'qtype_essay_monospaced';
440     }