Merge branch 'MDL-48771-squashed' of git://github.com/timhunt/moodle
[moodle.git] / mod / quiz / classes / output / edit_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  * Renderer outputting the quiz editing UI.
19  *
20  * @package mod_quiz
21  * @copyright 2013 The Open University.
22  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
23  */
25 namespace mod_quiz\output;
26 defined('MOODLE_INTERNAL') || die();
28 use \mod_quiz\structure;
29 use \html_writer;
30 use renderable;
32 /**
33  * Renderer outputting the quiz editing UI.
34  *
35  * @copyright 2013 The Open University.
36  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
37  * @since Moodle 2.7
38  */
39 class edit_renderer extends \plugin_renderer_base {
41     /**
42      * Render the edit page
43      *
44      * @param \quiz $quizobj object containing all the quiz settings information.
45      * @param structure $structure object containing the structure of the quiz.
46      * @param \question_edit_contexts $contexts the relevant question bank contexts.
47      * @param \moodle_url $pageurl the canonical URL of this page.
48      * @param array $pagevars the variables from {@link question_edit_setup()}.
49      * @return string HTML to output.
50      */
51     public function edit_page(\quiz $quizobj, structure $structure,
52             \question_edit_contexts $contexts, \moodle_url $pageurl, array $pagevars) {
53         $output = '';
55         // Page title.
56         $output .= $this->heading_with_help(get_string('editingquizx', 'quiz',
57                 format_string($quizobj->get_quiz_name())), 'editingquiz', 'quiz', '',
58                 get_string('basicideasofquiz', 'quiz'), 2);
60         // Information at the top.
61         $output .= $this->quiz_state_warnings($structure);
63         $output .= html_writer::start_div('mod_quiz-edit-top-controls');
64         $output .= $this->quiz_information($structure);
65         $output .= $this->maximum_grade_input($structure, $pageurl);
67         $output .= html_writer::start_div('mod_quiz-edit-action-buttons btn-group edit-toolbar', ['role' => 'group']);
68         $output .= $this->repaginate_button($structure, $pageurl);
69         $output .= $this->selectmultiple_button($structure);
70         $output .= html_writer::end_tag('div');
72         $output .= $this->total_marks($quizobj->get_quiz());
74         $output .= $this->selectmultiple_controls($structure);
75         $output .= html_writer::end_tag('div');
77         // Show the questions organised into sections and pages.
78         $output .= $this->start_section_list($structure);
80         foreach ($structure->get_sections() as $section) {
81             $output .= $this->start_section($structure, $section);
82             $output .= $this->questions_in_section($structure, $section, $contexts, $pagevars, $pageurl);
84             if ($structure->is_last_section($section)) {
85                 $output .= \html_writer::start_div('last-add-menu');
86                 $output .= html_writer::tag('span', $this->add_menu_actions($structure, 0,
87                         $pageurl, $contexts, $pagevars), array('class' => 'add-menu-outer'));
88                 $output .= \html_writer::end_div();
89             }
91             $output .= $this->end_section();
92         }
94         $output .= $this->end_section_list();
96         // Initialise the JavaScript.
97         $this->initialise_editing_javascript($structure, $contexts, $pagevars, $pageurl);
99         // Include the contents of any other popups required.
100         if ($structure->can_be_edited()) {
101             $popups = '';
103             $popups .= $this->question_bank_loading();
104             $this->page->requires->yui_module('moodle-mod_quiz-quizquestionbank',
105                     'M.mod_quiz.quizquestionbank.init',
106                     array('class' => 'questionbank', 'cmid' => $structure->get_cmid()));
108             $popups .= $this->random_question_form($pageurl, $contexts, $pagevars);
109             $this->page->requires->yui_module('moodle-mod_quiz-randomquestion',
110                     'M.mod_quiz.randomquestion.init');
112             $output .= html_writer::div($popups, 'mod_quiz_edit_forms');
114             // Include the question chooser.
115             $output .= $this->question_chooser();
116         }
118         return $output;
119     }
121     /**
122      * Render any warnings that might be required about the state of the quiz,
123      * e.g. if it has been attempted, or if the shuffle questions option is
124      * turned on.
125      *
126      * @param structure $structure the quiz structure.
127      * @return string HTML to output.
128      */
129     public function quiz_state_warnings(structure $structure) {
130         $warnings = $structure->get_edit_page_warnings();
132         if (empty($warnings)) {
133             return '';
134         }
136         $output = array();
137         foreach ($warnings as $warning) {
138             $output[] = \html_writer::tag('p', $warning);
139         }
140         return $this->box(implode("\n", $output), 'statusdisplay');
141     }
143     /**
144      * Render the status bar.
145      *
146      * @param structure $structure the quiz structure.
147      * @return string HTML to output.
148      */
149     public function quiz_information(structure $structure) {
150         list($currentstatus, $explanation) = $structure->get_dates_summary();
152         $output = html_writer::span(
153                     get_string('numquestionsx', 'quiz', $structure->get_question_count()),
154                     'numberofquestions') . ' | ' .
155                 html_writer::span($currentstatus, 'quizopeningstatus',
156                     array('title' => $explanation));
158         return html_writer::div($output, 'statusbar');
159     }
161     /**
162      * Render the form for setting a quiz' overall grade
163      *
164      * @param structure $structure the quiz structure.
165      * @param \moodle_url $pageurl the canonical URL of this page.
166      * @return string HTML to output.
167      */
168     public function maximum_grade_input($structure, \moodle_url $pageurl) {
169         $output = '';
170         $output .= html_writer::start_div('maxgrade');
171         $output .= html_writer::start_tag('form', array('method' => 'post', 'action' => 'edit.php',
172                 'class' => 'quizsavegradesform form-inline'));
173         $output .= html_writer::start_tag('fieldset', array('class' => 'invisiblefieldset'));
174         $output .= html_writer::empty_tag('input', array('type' => 'hidden', 'name' => 'sesskey', 'value' => sesskey()));
175         $output .= html_writer::input_hidden_params($pageurl);
176         $output .= html_writer::tag('label', get_string('maximumgrade') . ' ',
177                 array('for' => 'inputmaxgrade'));
178         $output .= html_writer::empty_tag('input', array('type' => 'text', 'id' => 'inputmaxgrade',
179                 'name' => 'maxgrade', 'size' => ($structure->get_decimal_places_for_grades() + 2),
180                 'value' => $structure->formatted_quiz_grade(),
181                 'class' => 'form-control'));
182         $output .= html_writer::empty_tag('input', array('type' => 'submit', 'class' => 'btn btn-secondary m-l-1',
183                 'name' => 'savechanges', 'value' => get_string('save', 'quiz')));
184         $output .= html_writer::end_tag('fieldset');
185         $output .= html_writer::end_tag('form');
186         $output .= html_writer::end_tag('div');
187         return $output;
188     }
190     /**
191      * Return the repaginate button
192      * @param structure $structure the structure of the quiz being edited.
193      * @param \moodle_url $pageurl the canonical URL of this page.
194      * @return string HTML to output.
195      */
196     protected function repaginate_button(structure $structure, \moodle_url $pageurl) {
198         $header = html_writer::tag('span', get_string('repaginatecommand', 'quiz'), array('class' => 'repaginatecommand'));
199         $form = $this->repaginate_form($structure, $pageurl);
201         $buttonoptions = array(
202             'type'  => 'submit',
203             'name'  => 'repaginate',
204             'id'    => 'repaginatecommand',
205             'value' => get_string('repaginatecommand', 'quiz'),
206             'class' => 'btn btn-secondary m-b-1',
207             'data-header' => $header,
208             'data-form'   => $form,
209         );
210         if (!$structure->can_be_repaginated()) {
211             $buttonoptions['disabled'] = 'disabled';
212         } else {
213             $this->page->requires->yui_module('moodle-mod_quiz-repaginate', 'M.mod_quiz.repaginate.init');
214         }
216         return html_writer::empty_tag('input', $buttonoptions);
217     }
219     /**
220      * Generate the bulk action button.
221      *
222      * @param structure $structure the structure of the quiz being edited.
223      * @return string HTML to output.
224      */
225     protected function selectmultiple_button(structure $structure) {
226         $buttonoptions = array(
227             'type'  => 'button',
228             'name'  => 'selectmultiple',
229             'id'    => 'selectmultiplecommand',
230             'value' => get_string('selectmultipleitems', 'quiz'),
231             'class' => 'btn btn-secondary m-b-1'
232         );
233         if (!$structure->can_be_edited()) {
234             $buttonoptions['disabled'] = 'disabled';
235         }
237         return html_writer::tag('button', get_string('selectmultipleitems', 'quiz'), $buttonoptions);
238     }
240     /**
241      * Generate the controls that appear when the bulk action button is pressed.
242      *
243      * @param structure $structure the structure of the quiz being edited.
244      * @return string HTML to output.
245      */
246     protected function selectmultiple_controls(structure $structure) {
247         $output = '';
249         // Bulk action button delete and bulk action button cancel.
250         $buttondeleteoptions = array(
251             'type' => 'button',
252             'id' => 'selectmultipledeletecommand',
253             'value' => get_string('deleteselected', 'mod_quiz'),
254             'class' => 'btn btn-secondary'
255         );
256         $buttoncanceloptions = array(
257             'type' => 'button',
258             'id' => 'selectmultiplecancelcommand',
259             'value' => get_string('cancel', 'moodle'),
260             'class' => 'btn btn-secondary'
261         );
263         $groupoptions = array(
264             'class' => 'btn-group selectmultiplecommand actions',
265             'role' => 'group'
266         );
268         $output .= html_writer::tag('div',
269                         html_writer::tag('button', get_string('deleteselected', 'mod_quiz'), $buttondeleteoptions) .
270                         " " .
271                         html_writer::tag('button', get_string('cancel', 'moodle'),
272                 $buttoncanceloptions), $groupoptions);
274         $toolbaroptions = array(
275             'class' => 'btn-toolbar',
276             'role' => 'toolbar',
277             'aria-label' => get_string('selectmultipletoolbar', 'quiz'),
278         );
280         // Select all/deselect all questions.
281         $buttonselectalloptions = array(
282             'role' => 'button',
283             'id' => 'questionselectall',
284             'class' => 'btn btn-link'
285         );
286         $buttondeselectalloptions = array(
287             'role' => 'button',
288             'id' => 'questiondeselectall',
289             'class' => 'btn btn-link'
290         );
291         $output .= html_writer::tag('div',
292                 html_writer::tag('div',
293                         html_writer::link('#', get_string('selectall', 'quiz'), $buttonselectalloptions) .
294                         html_writer::tag('span', "/", ['class' => 'separator']) .
295                         html_writer::link('#', get_string('selectnone', 'quiz'), $buttondeselectalloptions),
296                         array('class' => 'btn-group selectmultiplecommandbuttons')),
297                 $toolbaroptions);
298         return $output;
299     }
301     /**
302      * Return the repaginate form
303      * @param structure $structure the structure of the quiz being edited.
304      * @param \moodle_url $pageurl the canonical URL of this page.
305      * @return string HTML to output.
306      */
307     protected function repaginate_form(structure $structure, \moodle_url $pageurl) {
308         $perpage = array();
309         $perpage[0] = get_string('allinone', 'quiz');
310         for ($i = 1; $i <= 50; ++$i) {
311             $perpage[$i] = $i;
312         }
314         $hiddenurl = clone($pageurl);
315         $hiddenurl->param('sesskey', sesskey());
317         $select = html_writer::select($perpage, 'questionsperpage',
318                 $structure->get_questions_per_page(), false, array('class' => 'custom-select'));
320         $buttonattributes = array(
321             'type' => 'submit',
322             'name' => 'repaginate',
323             'value' => get_string('go'),
324             'class' => 'btn btn-secondary m-l-1'
325         );
327         $formcontent = html_writer::tag('form', html_writer::div(
328                     html_writer::input_hidden_params($hiddenurl) .
329                     get_string('repaginate', 'quiz', $select) .
330                     html_writer::empty_tag('input', $buttonattributes)
331                 ), array('action' => 'edit.php', 'method' => 'post'));
333         return html_writer::div($formcontent, '', array('id' => 'repaginatedialog'));
334     }
336     /**
337      * Render the total marks available for the quiz.
338      *
339      * @param \stdClass $quiz the quiz settings from the database.
340      * @return string HTML to output.
341      */
342     public function total_marks($quiz) {
343         $totalmark = html_writer::span(quiz_format_grade($quiz, $quiz->sumgrades), 'mod_quiz_summarks');
344         return html_writer::tag('span',
345                 get_string('totalmarksx', 'quiz', $totalmark),
346                 array('class' => 'totalpoints'));
347     }
349     /**
350      * Generate the starting container html for the start of a list of sections
351      * @param structure $structure the structure of the quiz being edited.
352      * @return string HTML to output.
353      */
354     protected function start_section_list(structure $structure) {
355         $class = 'slots';
356         if ($structure->get_section_count() == 1) {
357             $class .= ' only-one-section';
358         }
359         return html_writer::start_tag('ul', array('class' => $class));
360     }
362     /**
363      * Generate the closing container html for the end of a list of sections
364      * @return string HTML to output.
365      */
366     protected function end_section_list() {
367         return html_writer::end_tag('ul');
368     }
370     /**
371      * Display the start of a section, before the questions.
372      *
373      * @param structure $structure the structure of the quiz being edited.
374      * @param \stdClass $section The quiz_section entry from DB
375      * @return string HTML to output.
376      */
377     protected function start_section($structure, $section) {
379         $output = '';
381         $sectionstyle = '';
382         if ($structure->is_only_one_slot_in_section($section)) {
383             $sectionstyle = ' only-has-one-slot';
384         }
386         $output .= html_writer::start_tag('li', array('id' => 'section-'.$section->id,
387             'class' => 'section main clearfix'.$sectionstyle, 'role' => 'region',
388             'aria-label' => $section->heading));
390         $output .= html_writer::start_div('content');
392         $output .= html_writer::start_div('section-heading');
394         $headingtext = $this->heading(html_writer::span(
395                 html_writer::span($section->heading, 'instancesection'), 'sectioninstance'), 3);
397         if (!$structure->can_be_edited()) {
398             $editsectionheadingicon = '';
399         } else {
400             $editsectionheadingicon = html_writer::link(new \moodle_url('#'),
401                 $this->pix_icon('t/editstring', get_string('sectionheadingedit', 'quiz', $section->heading),
402                         'moodle', array('class' => 'editicon visibleifjs')),
403                         array('class' => 'editing_section', 'data-action' => 'edit_section_title'));
404         }
405         $output .= html_writer::div($headingtext . $editsectionheadingicon, 'instancesectioncontainer');
407         if (!$structure->is_first_section($section) && $structure->can_be_edited()) {
408             $output .= $this->section_remove_icon($section);
409         }
410         $output .= $this->section_shuffle_questions($structure, $section);
412         $output .= html_writer::end_div($output, 'section-heading');
414         return $output;
415     }
417     /**
418      * Display a checkbox for shuffling question within a section.
419      *
420      * @param structure $structure object containing the structure of the quiz.
421      * @param \stdClass $section data from the quiz_section table.
422      * @return string HTML to output.
423      */
424     public function section_shuffle_questions(structure $structure, $section) {
425         $checkboxattributes = array(
426             'type' => 'checkbox',
427             'id' => 'shuffle-' . $section->id,
428             'value' => 1,
429             'data-action' => 'shuffle_questions',
430             'class' => 'cm-edit-action',
431         );
433         if (!$structure->can_be_edited()) {
434             $checkboxattributes['disabled'] = 'disabled';
435         }
436         if ($section->shufflequestions) {
437             $checkboxattributes['checked'] = 'checked';
438         }
440         if ($structure->is_first_section($section)) {
441             $help = $this->help_icon('shufflequestions', 'quiz');
442         } else {
443             $help = '';
444         }
446         $progressspan = html_writer::span('', 'shuffle-progress');
447         $checkbox = html_writer::empty_tag('input', $checkboxattributes);
448         $label = html_writer::label(get_string('shufflequestions', 'quiz') . ' ' . $help,
449                 $checkboxattributes['id'], false);
450         return html_writer::span($progressspan . $checkbox . $label,
451                 'instanceshufflequestions', array('data-action' => 'shuffle_questions'));
452     }
454     /**
455      * Display the end of a section, after the questions.
456      *
457      * @return string HTML to output.
458      */
459     protected function end_section() {
460         $output = html_writer::end_tag('div');
461         $output .= html_writer::end_tag('li');
463         return $output;
464     }
466     /**
467      * Render an icon to remove a section from the quiz.
468      *
469      * @param object $section the section to be removed.
470      * @return string HTML to output.
471      */
472     public function section_remove_icon($section) {
473         $title = get_string('sectionheadingremove', 'quiz', $section->heading);
474         $url = new \moodle_url('/mod/quiz/edit.php',
475                 array('sesskey' => sesskey(), 'removesection' => '1', 'sectionid' => $section->id));
476         $image = $this->pix_icon('t/delete', $title);
477         return $this->action_link($url, $image, null, array(
478                 'class' => 'cm-edit-action editing_delete', 'data-action' => 'deletesection'));
479     }
481     /**
482      * Renders HTML to display the questions in a section of the quiz.
483      *
484      * This function calls {@link core_course_renderer::quiz_section_question()}
485      *
486      * @param structure $structure object containing the structure of the quiz.
487      * @param \stdClass $section information about the section.
488      * @param \question_edit_contexts $contexts the relevant question bank contexts.
489      * @param array $pagevars the variables from {@link \question_edit_setup()}.
490      * @param \moodle_url $pageurl the canonical URL of this page.
491      * @return string HTML to output.
492      */
493     public function questions_in_section(structure $structure, $section,
494             $contexts, $pagevars, $pageurl) {
496         $output = '';
497         foreach ($structure->get_slots_in_section($section->id) as $slot) {
498             $output .= $this->question_row($structure, $slot, $contexts, $pagevars, $pageurl);
499         }
500         return html_writer::tag('ul', $output, array('class' => 'section img-text'));
501     }
503     /**
504      * Displays one question with the surrounding controls.
505      *
506      * @param structure $structure object containing the structure of the quiz.
507      * @param int $slot which slot we are outputting.
508      * @param \question_edit_contexts $contexts the relevant question bank contexts.
509      * @param array $pagevars the variables from {@link \question_edit_setup()}.
510      * @param \moodle_url $pageurl the canonical URL of this page.
511      * @return string HTML to output.
512      */
513     public function question_row(structure $structure, $slot, $contexts, $pagevars, $pageurl) {
514         $output = '';
516         $output .= $this->page_row($structure, $slot, $contexts, $pagevars, $pageurl);
518         // Page split/join icon.
519         $joinhtml = '';
520         if ($structure->can_be_edited() && !$structure->is_last_slot_in_quiz($slot) &&
521                                             !$structure->is_last_slot_in_section($slot)) {
522             $joinhtml = $this->page_split_join_button($structure, $slot);
523         }
524         // Question HTML.
525         $questionhtml = $this->question($structure, $slot, $pageurl);
526         $qtype = $structure->get_question_type_for_slot($slot);
527         $questionclasses = 'activity ' . $qtype . ' qtype_' . $qtype . ' slot';
529         $output .= html_writer::tag('li', $questionhtml . $joinhtml,
530                 array('class' => $questionclasses, 'id' => 'slot-' . $structure->get_slot_id_for_slot($slot),
531                         'data-canfinish' => $structure->can_finish_during_the_attempt($slot)));
533         return $output;
534     }
536     /**
537      * Displays one question with the surrounding controls.
538      *
539      * @param structure $structure object containing the structure of the quiz.
540      * @param int $slot the first slot on the page we are outputting.
541      * @param \question_edit_contexts $contexts the relevant question bank contexts.
542      * @param array $pagevars the variables from {@link \question_edit_setup()}.
543      * @param \moodle_url $pageurl the canonical URL of this page.
544      * @return string HTML to output.
545      */
546     public function page_row(structure $structure, $slot, $contexts, $pagevars, $pageurl) {
547         $output = '';
549         $pagenumber = $structure->get_page_number_for_slot($slot);
551         // Put page in a heading for accessibility and styling.
552         $page = $this->heading(get_string('page') . ' ' . $pagenumber, 4);
554         if ($structure->is_first_slot_on_page($slot)) {
555             // Add the add-menu at the page level.
556             $addmenu = html_writer::tag('span', $this->add_menu_actions($structure,
557                     $pagenumber, $pageurl, $contexts, $pagevars),
558                     array('class' => 'add-menu-outer'));
560             $addquestionform = $this->add_question_form($structure,
561                     $pagenumber, $pageurl, $pagevars);
563             $output .= html_writer::tag('li', $page . $addmenu . $addquestionform,
564                     array('class' => 'pagenumber activity yui3-dd-drop page', 'id' => 'page-' . $pagenumber));
565         }
567         return $output;
568     }
570     /**
571      * Returns the add menu that is output once per page.
572      * @param structure $structure object containing the structure of the quiz.
573      * @param int $page the page number that this menu will add to.
574      * @param \moodle_url $pageurl the canonical URL of this page.
575      * @param \question_edit_contexts $contexts the relevant question bank contexts.
576      * @param array $pagevars the variables from {@link \question_edit_setup()}.
577      * @return string HTML to output.
578      */
579     public function add_menu_actions(structure $structure, $page, \moodle_url $pageurl,
580             \question_edit_contexts $contexts, array $pagevars) {
582         $actions = $this->edit_menu_actions($structure, $page, $pageurl, $pagevars);
583         if (empty($actions)) {
584             return '';
585         }
586         $menu = new \action_menu();
587         $menu->set_alignment(\action_menu::TR, \action_menu::TR);
588         $menu->set_constraint('.mod-quiz-edit-content');
589         $trigger = html_writer::tag('span', get_string('add', 'quiz'), array('class' => 'add-menu'));
590         $menu->set_menu_trigger($trigger);
591         // The menu appears within an absolutely positioned element causing width problems.
592         // Make sure no-wrap is set so that we don't get a squashed menu.
593         $menu->set_nowrap_on_items(true);
595         // Disable the link if quiz has attempts.
596         if (!$structure->can_be_edited()) {
597             return $this->render($menu);
598         }
600         foreach ($actions as $action) {
601             if ($action instanceof \action_menu_link) {
602                 $action->add_class('add-menu');
603             }
604             $menu->add($action);
605         }
606         $menu->attributes['class'] .= ' page-add-actions commands';
608         // Prioritise the menu ahead of all other actions.
609         $menu->prioritise = true;
611         return $this->render($menu);
612     }
614     /**
615      * Returns the list of actions to go in the add menu.
616      * @param structure $structure object containing the structure of the quiz.
617      * @param int $page the page number that this menu will add to.
618      * @param \moodle_url $pageurl the canonical URL of this page.
619      * @param array $pagevars the variables from {@link \question_edit_setup()}.
620      * @return array the actions.
621      */
622     public function edit_menu_actions(structure $structure, $page,
623             \moodle_url $pageurl, array $pagevars) {
624         $questioncategoryid = question_get_category_id_from_pagevars($pagevars);
625         static $str;
626         if (!isset($str)) {
627             $str = get_strings(array('addasection', 'addaquestion', 'addarandomquestion',
628                     'addarandomselectedquestion', 'questionbank'), 'quiz');
629         }
631         // Get section, page, slotnumber and maxmark.
632         $actions = array();
634         // Add a new section to the add_menu if possible. This is always added to the HTML
635         // then hidden with CSS when no needed, so that as things are re-ordered, etc. with
636         // Ajax it can be relevaled again when necessary.
637         $params = array('cmid' => $structure->get_cmid(), 'addsectionatpage' => $page);
639         $actions['addasection'] = new \action_menu_link_secondary(
640                 new \moodle_url($pageurl, $params),
641                 new \pix_icon('t/add', $str->addasection, 'moodle', array('class' => 'iconsmall', 'title' => '')),
642                 $str->addasection, array('class' => 'cm-edit-action addasection', 'data-action' => 'addasection')
643         );
645         // Add a new question to the quiz.
646         $returnurl = new \moodle_url($pageurl, array('addonpage' => $page));
647         $params = array('returnurl' => $returnurl->out_as_local_url(false),
648                 'cmid' => $structure->get_cmid(), 'category' => $questioncategoryid,
649                 'addonpage' => $page, 'appendqnumstring' => 'addquestion');
651         $actions['addaquestion'] = new \action_menu_link_secondary(
652             new \moodle_url('/question/addquestion.php', $params),
653             new \pix_icon('t/add', $str->addaquestion, 'moodle', array('class' => 'iconsmall', 'title' => '')),
654             $str->addaquestion, array('class' => 'cm-edit-action addquestion', 'data-action' => 'addquestion')
655         );
657         // Call question bank.
658         $icon = new \pix_icon('t/add', $str->questionbank, 'moodle', array('class' => 'iconsmall', 'title' => ''));
659         if ($page) {
660             $title = get_string('addquestionfrombanktopage', 'quiz', $page);
661         } else {
662             $title = get_string('addquestionfrombankatend', 'quiz');
663         }
664         $attributes = array('class' => 'cm-edit-action questionbank',
665                 'data-header' => $title, 'data-action' => 'questionbank', 'data-addonpage' => $page);
666         $actions['questionbank'] = new \action_menu_link_secondary($pageurl, $icon, $str->questionbank, $attributes);
668         // Add a random question.
669         $returnurl = new \moodle_url('/mod/quiz/edit.php', array('cmid' => $structure->get_cmid(), 'data-addonpage' => $page));
670         $params = array('returnurl' => $returnurl, 'cmid' => $structure->get_cmid(), 'appendqnumstring' => 'addarandomquestion');
671         $url = new \moodle_url('/mod/quiz/addrandom.php', $params);
672         $icon = new \pix_icon('t/add', $str->addarandomquestion, 'moodle', array('class' => 'iconsmall', 'title' => ''));
673         $attributes = array('class' => 'cm-edit-action addarandomquestion', 'data-action' => 'addarandomquestion');
674         if ($page) {
675             $title = get_string('addrandomquestiontopage', 'quiz', $page);
676         } else {
677             $title = get_string('addrandomquestionatend', 'quiz');
678         }
679         $attributes = array_merge(array('data-header' => $title, 'data-addonpage' => $page), $attributes);
680         $actions['addarandomquestion'] = new \action_menu_link_secondary($url, $icon, $str->addarandomquestion, $attributes);
682         return $actions;
683     }
685     /**
686      * Render the form that contains the data for adding a new question to the quiz.
687      *
688      * @param structure $structure object containing the structure of the quiz.
689      * @param int $page the page number that this menu will add to.
690      * @param \moodle_url $pageurl the canonical URL of this page.
691      * @param array $pagevars the variables from {@link \question_edit_setup()}.
692      * @return string HTML to output.
693      */
694     protected function add_question_form(structure $structure, $page, \moodle_url $pageurl, array $pagevars) {
696         $questioncategoryid = question_get_category_id_from_pagevars($pagevars);
698         $output = html_writer::tag('input', null,
699                 array('type' => 'hidden', 'name' => 'returnurl',
700                         'value' => $pageurl->out_as_local_url(false, array('addonpage' => $page))));
701         $output .= html_writer::tag('input', null,
702                 array('type' => 'hidden', 'name' => 'cmid', 'value' => $structure->get_cmid()));
703         $output .= html_writer::tag('input', null,
704                 array('type' => 'hidden', 'name' => 'appendqnumstring', 'value' => 'addquestion'));
705         $output .= html_writer::tag('input', null,
706                 array('type' => 'hidden', 'name' => 'category', 'value' => $questioncategoryid));
708         return html_writer::tag('form', html_writer::div($output),
709                 array('class' => 'addnewquestion', 'method' => 'post',
710                         'action' => new \moodle_url('/question/addquestion.php')));
711     }
713     /**
714      * Display a question.
715      *
716      * @param structure $structure object containing the structure of the quiz.
717      * @param int $slot the first slot on the page we are outputting.
718      * @param \moodle_url $pageurl the canonical URL of this page.
719      * @return string HTML to output.
720      */
721     public function question(structure $structure, $slot, \moodle_url $pageurl) {
722         $output = '';
723         $output .= html_writer::start_tag('div');
725         if ($structure->can_be_edited()) {
726             $output .= $this->question_move_icon($structure, $slot);
727         }
729         $output .= html_writer::start_div('mod-indent-outer');
730         $output .= html_writer::tag('input', '', array('id' => 'selectquestion-' .
731                 $structure->get_displayed_number_for_slot($slot), 'name' => 'selectquestion[]',
732                'type' => 'checkbox', 'class' => 'select-multiple-checkbox',
733                'value' => $structure->get_displayed_number_for_slot($slot)));
734         $output .= $this->question_number($structure->get_displayed_number_for_slot($slot));
736         // This div is used to indent the content.
737         $output .= html_writer::div('', 'mod-indent');
739         // Display the link to the question (or do nothing if question has no url).
740         if ($structure->get_question_type_for_slot($slot) == 'random') {
741             $questionname = $this->random_question($structure, $slot, $pageurl);
742         } else {
743             $questionname = $this->question_name($structure, $slot, $pageurl);
744         }
746         // Start the div for the activity title, excluding the edit icons.
747         $output .= html_writer::start_div('activityinstance');
748         $output .= $questionname;
750         // Closing the tag which contains everything but edit icons. Content part of the module should not be part of this.
751         $output .= html_writer::end_tag('div'); // .activityinstance.
753         // Action icons.
754         $questionicons = '';
755         $questionicons .= $this->question_preview_icon($structure->get_quiz(), $structure->get_question_in_slot($slot));
756         if ($structure->can_be_edited()) {
757             $questionicons .= $this->question_remove_icon($structure, $slot, $pageurl);
758         }
759         $questionicons .= $this->marked_out_of_field($structure, $slot);
760         $output .= html_writer::span($questionicons, 'actions'); // Required to add js spinner icon.
761         if ($structure->can_be_edited()) {
762             $output .= $this->question_dependency_icon($structure, $slot);
763         }
765         // End of indentation div.
766         $output .= html_writer::end_tag('div');
767         $output .= html_writer::end_tag('div');
769         return $output;
770     }
772     /**
773      * Render the move icon.
774      *
775      * @param structure $structure object containing the structure of the quiz.
776      * @param int $slot the first slot on the page we are outputting.
777      * @return string The markup for the move action.
778      */
779     public function question_move_icon(structure $structure, $slot) {
780         return html_writer::link(new \moodle_url('#'),
781             $this->pix_icon('i/dragdrop', get_string('move'), 'moodle', array('class' => 'iconsmall', 'title' => '')),
782             array('class' => 'editing_move', 'data-action' => 'move')
783         );
784     }
786     /**
787      * Output the question number.
788      * @param string $number The number, or 'i'.
789      * @return string HTML to output.
790      */
791     public function question_number($number) {
792         if (is_numeric($number)) {
793             $number = html_writer::span(get_string('question'), 'accesshide') . ' ' . $number;
794         }
795         return html_writer::tag('span', $number, array('class' => 'slotnumber'));
796     }
798     /**
799      * Render the preview icon.
800      *
801      * @param \stdClass $quiz the quiz settings from the database.
802      * @param \stdClass $question data from the question and quiz_slots tables.
803      * @param bool $label if true, show the preview question label after the icon
804      * @param int $variant which question variant to preview (optional).
805      * @return string HTML to output.
806      */
807     public function question_preview_icon($quiz, $question, $label = null, $variant = null) {
808         $url = quiz_question_preview_url($quiz, $question, $variant);
810         // Do we want a label?
811         $strpreviewlabel = '';
812         if ($label) {
813             $strpreviewlabel = ' ' . get_string('preview', 'quiz');
814         }
816         // Build the icon.
817         $strpreviewquestion = get_string('previewquestion', 'quiz');
818         $image = $this->pix_icon('t/preview', $strpreviewquestion);
820         $action = new \popup_action('click', $url, 'questionpreview',
821                                         question_preview_popup_params());
823         return $this->action_link($url, $image . $strpreviewlabel, $action,
824                 array('title' => $strpreviewquestion, 'class' => 'preview'));
825     }
827     /**
828      * Render an icon to remove a question from the quiz.
829      *
830      * @param structure $structure object containing the structure of the quiz.
831      * @param int $slot the first slot on the page we are outputting.
832      * @param \moodle_url $pageurl the canonical URL of the edit page.
833      * @return string HTML to output.
834      */
835     public function question_remove_icon(structure $structure, $slot, $pageurl) {
836         $url = new \moodle_url($pageurl, array('sesskey' => sesskey(), 'remove' => $slot));
837         $strdelete = get_string('delete');
839         $image = $this->pix_icon('t/delete', $strdelete);
841         return $this->action_link($url, $image, null, array('title' => $strdelete,
842                     'class' => 'cm-edit-action editing_delete', 'data-action' => 'delete'));
843     }
845     /**
846      * Display an icon to split or join two pages of the quiz.
847      *
848      * @param structure $structure object containing the structure of the quiz.
849      * @param int $slot the first slot on the page we are outputting.
850      * @return string HTML to output.
851      */
852     public function page_split_join_button($structure, $slot) {
853         $insertpagebreak = !$structure->is_last_slot_on_page($slot);
854         $url = new \moodle_url('repaginate.php', array('quizid' => $structure->get_quizid(),
855                 'slot' => $slot, 'repag' => $insertpagebreak ? 2 : 1, 'sesskey' => sesskey()));
857         if ($insertpagebreak) {
858             $title = get_string('addpagebreak', 'quiz');
859             $image = $this->image_icon('e/insert_page_break', $title);
860             $action = 'addpagebreak';
861         } else {
862             $title = get_string('removepagebreak', 'quiz');
863             $image = $this->image_icon('e/remove_page_break', $title);
864             $action = 'removepagebreak';
865         }
867         // Disable the link if quiz has attempts.
868         $disabled = null;
869         if (!$structure->can_be_edited()) {
870             $disabled = 'disabled';
871         }
872         return html_writer::span($this->action_link($url, $image, null, array('title' => $title,
873                     'class' => 'page_split_join cm-edit-action', 'disabled' => $disabled, 'data-action' => $action)),
874                 'page_split_join_wrapper');
875     }
877     /**
878      * Display the icon for whether this question can only be seen if the previous
879      * one has been answered.
880      *
881      * @param structure $structure object containing the structure of the quiz.
882      * @param int $slot the first slot on the page we are outputting.
883      * @return string HTML to output.
884      */
885     public function question_dependency_icon($structure, $slot) {
886         $a = array(
887             'thisq' => $structure->get_displayed_number_for_slot($slot),
888             'previousq' => $structure->get_displayed_number_for_slot(max($slot - 1, 1)),
889         );
890         if ($structure->is_question_dependent_on_previous_slot($slot)) {
891             $title = get_string('questiondependencyremove', 'quiz', $a);
892             $image = $this->pix_icon('t/locked', get_string('questiondependsonprevious', 'quiz'),
893                     'moodle', array('title' => ''));
894             $action = 'removedependency';
895         } else {
896             $title = get_string('questiondependencyadd', 'quiz', $a);
897             $image = $this->pix_icon('t/unlocked', get_string('questiondependencyfree', 'quiz'),
898                     'moodle', array('title' => ''));
899             $action = 'adddependency';
900         }
902         // Disable the link if quiz has attempts.
903         $disabled = null;
904         if (!$structure->can_be_edited()) {
905             $disabled = 'disabled';
906         }
907         $extraclass = '';
908         if (!$structure->can_question_depend_on_previous_slot($slot)) {
909             $extraclass = ' question_dependency_cannot_depend';
910         }
911         return html_writer::span($this->action_link('#', $image, null, array('title' => $title,
912                 'class' => 'cm-edit-action', 'disabled' => $disabled, 'data-action' => $action)),
913                 'question_dependency_wrapper' . $extraclass);
914     }
916     /**
917      * Renders html to display a name with the link to the question on a quiz edit page
918      *
919      * If the user does not have permission to edi the question, it is rendered
920      * without a link
921      *
922      * @param structure $structure object containing the structure of the quiz.
923      * @param int $slot which slot we are outputting.
924      * @param \moodle_url $pageurl the canonical URL of this page.
925      * @return string HTML to output.
926      */
927     public function question_name(structure $structure, $slot, $pageurl) {
928         $output = '';
930         $question = $structure->get_question_in_slot($slot);
931         $editurl = new \moodle_url('/question/question.php', array(
932                 'returnurl' => $pageurl->out_as_local_url(),
933                 'cmid' => $structure->get_cmid(), 'id' => $question->id));
935         $instancename = quiz_question_tostring($question);
937         $qtype = \question_bank::get_qtype($question->qtype, false);
938         $namestr = $qtype->local_name();
940         $icon = $this->pix_icon('icon', $namestr, $qtype->plugin_name(), array('title' => $namestr,
941                 'class' => 'icon activityicon', 'alt' => ' ', 'role' => 'presentation'));
943         $editicon = $this->pix_icon('t/edit', '', 'moodle', array('title' => ''));
945         // Need plain question name without html tags for link title.
946         $title = shorten_text(format_string($question->name), 100);
948         // Display the link itself.
949         $activitylink = $icon . html_writer::tag('span', $editicon . $instancename, array('class' => 'instancename'));
950         $output .= html_writer::link($editurl, $activitylink,
951                 array('title' => get_string('editquestion', 'quiz').' '.$title));
953         return $output;
954     }
956     /**
957      * Renders html to display a random question the link to edit the configuration
958      * and also to see that category in the question bank.
959      *
960      * @param structure $structure object containing the structure of the quiz.
961      * @param int $slot which slot we are outputting.
962      * @param \moodle_url $pageurl the canonical URL of this page.
963      * @return string HTML to output.
964      */
965     public function random_question(structure $structure, $slot, $pageurl) {
967         $question = $structure->get_question_in_slot($slot);
968         $editurl = new \moodle_url('/question/question.php', array(
969                 'returnurl' => $pageurl->out_as_local_url(),
970                 'cmid' => $structure->get_cmid(), 'id' => $question->id));
972         $temp = clone($question);
973         $temp->questiontext = '';
974         $instancename = quiz_question_tostring($temp);
976         $configuretitle = get_string('configurerandomquestion', 'quiz');
977         $qtype = \question_bank::get_qtype($question->qtype, false);
978         $namestr = $qtype->local_name();
979         $icon = $this->pix_icon('icon', $namestr, $qtype->plugin_name(), array('title' => $namestr,
980                 'class' => 'icon activityicon', 'alt' => ' ', 'role' => 'presentation'));
982         $editicon = $this->pix_icon('t/edit', $configuretitle, 'moodle', array('title' => ''));
984         // If this is a random question, display a link to show the questions
985         // selected from in the question bank.
986         $qbankurl = new \moodle_url('/question/edit.php', array(
987                 'cmid' => $structure->get_cmid(),
988                 'cat' => $question->category . ',' . $question->contextid,
989                 'recurse' => !empty($question->questiontext)));
990         $qbanklink = ' ' . \html_writer::link($qbankurl,
991                 get_string('seequestions', 'quiz'), array('class' => 'mod_quiz_random_qbank_link'));
993         return html_writer::link($editurl, $icon . $editicon, array('title' => $configuretitle)) .
994                 ' ' . $instancename . ' ' . $qbanklink;
995     }
997     /**
998      * Display the 'marked out of' information for a question.
999      * Along with the regrade action.
1000      * @param structure $structure object containing the structure of the quiz.
1001      * @param int $slot which slot we are outputting.
1002      * @return string HTML to output.
1003      */
1004     public function marked_out_of_field(structure $structure, $slot) {
1005         if (!$structure->is_real_question($slot)) {
1006             $output = html_writer::span('',
1007                     'instancemaxmark decimalplaces_' . $structure->get_decimal_places_for_question_marks());
1009             $output .= html_writer::span(
1010                     $this->pix_icon('spacer', '', 'moodle', array('class' => 'editicon visibleifjs', 'title' => '')),
1011                     'editing_maxmark');
1012             return html_writer::span($output, 'instancemaxmarkcontainer infoitem');
1013         }
1015         $output = html_writer::span($structure->formatted_question_grade($slot),
1016                 'instancemaxmark decimalplaces_' . $structure->get_decimal_places_for_question_marks(),
1017                 array('title' => get_string('maxmark', 'quiz')));
1019         $output .= html_writer::span(
1020             html_writer::link(
1021                 new \moodle_url('#'),
1022                 $this->pix_icon('t/editstring', '', 'moodle', array('class' => 'editicon visibleifjs', 'title' => '')),
1023                 array(
1024                     'class' => 'editing_maxmark',
1025                     'data-action' => 'editmaxmark',
1026                     'title' => get_string('editmaxmark', 'quiz'),
1027                 )
1028             )
1029         );
1030         return html_writer::span($output, 'instancemaxmarkcontainer');
1031     }
1033     /**
1034      * Renders the question chooser.
1035      *
1036      * @param renderable
1037      * @return string
1038      */
1039     public function render_question_chooser(renderable $chooser) {
1040         return $this->render_from_template('mod_quiz/question_chooser', $chooser->export_for_template($this));
1041     }
1043     /**
1044      * Render the question type chooser dialogue.
1045      * @return string HTML to output.
1046      */
1047     public function question_chooser() {
1048         $chooser = \mod_quiz\output\question_chooser::get($this->page->course, [], null);
1049         $container = html_writer::div($this->render($chooser), '', array('id' => 'qtypechoicecontainer'));
1050         return html_writer::div($container, 'createnewquestion');
1051     }
1053     /**
1054      * Render the contents of the question bank pop-up in its initial state,
1055      * when it just contains a loading progress indicator.
1056      * @return string HTML to output.
1057      */
1058     public function question_bank_loading() {
1059         return html_writer::div($this->pix_icon('i/loading', get_string('loading')), 'questionbankloading');
1060     }
1062     /**
1063      * Return random question form.
1064      * @param \moodle_url $thispageurl the canonical URL of this page.
1065      * @param \question_edit_contexts $contexts the relevant question bank contexts.
1066      * @param array $pagevars the variables from {@link \question_edit_setup()}.
1067      * @return string HTML to output.
1068      */
1069     protected function random_question_form(\moodle_url $thispageurl, \question_edit_contexts $contexts, array $pagevars) {
1071         if (!$contexts->have_cap('moodle/question:useall')) {
1072             return '';
1073         }
1074         $randomform = new \quiz_add_random_form(new \moodle_url('/mod/quiz/addrandom.php'),
1075                                  array('contexts' => $contexts, 'cat' => $pagevars['cat']));
1076         $randomform->set_data(array(
1077                 'category' => $pagevars['cat'],
1078                 'returnurl' => $thispageurl->out_as_local_url(true),
1079                 'randomnumber' => 1,
1080                 'cmid' => $thispageurl->param('cmid'),
1081         ));
1082         return html_writer::div($randomform->render(), 'randomquestionformforpopup');
1083     }
1085     /**
1086      * Initialise the JavaScript for the general editing. (JavaScript for popups
1087      * is handled with the specific code for those.)
1088      *
1089      * @param structure $structure object containing the structure of the quiz.
1090      * @param \question_edit_contexts $contexts the relevant question bank contexts.
1091      * @param array $pagevars the variables from {@link \question_edit_setup()}.
1092      * @param \moodle_url $pageurl the canonical URL of this page.
1093      * @return bool Always returns true
1094      */
1095     protected function initialise_editing_javascript(structure $structure,
1096             \question_edit_contexts $contexts, array $pagevars, \moodle_url $pageurl) {
1098         $config = new \stdClass();
1099         $config->resourceurl = '/mod/quiz/edit_rest.php';
1100         $config->sectionurl = '/mod/quiz/edit_rest.php';
1101         $config->pageparams = array();
1102         $config->questiondecimalpoints = $structure->get_decimal_places_for_question_marks();
1103         $config->pagehtml = $this->new_page_template($structure, $contexts, $pagevars, $pageurl);
1104         $config->addpageiconhtml = $this->add_page_icon_template($structure);
1106         $this->page->requires->yui_module('moodle-mod_quiz-toolboxes',
1107                 'M.mod_quiz.init_resource_toolbox',
1108                 array(array(
1109                         'courseid' => $structure->get_courseid(),
1110                         'quizid' => $structure->get_quizid(),
1111                         'ajaxurl' => $config->resourceurl,
1112                         'config' => $config,
1113                 ))
1114         );
1115         unset($config->pagehtml);
1116         unset($config->addpageiconhtml);
1118         $this->page->requires->strings_for_js(array('areyousureremoveselected'), 'quiz');
1119         $this->page->requires->yui_module('moodle-mod_quiz-toolboxes',
1120                 'M.mod_quiz.init_section_toolbox',
1121                 array(array(
1122                         'courseid' => $structure,
1123                         'quizid' => $structure->get_quizid(),
1124                         'ajaxurl' => $config->sectionurl,
1125                         'config' => $config,
1126                 ))
1127         );
1129         $this->page->requires->yui_module('moodle-mod_quiz-dragdrop', 'M.mod_quiz.init_section_dragdrop',
1130                 array(array(
1131                         'courseid' => $structure,
1132                         'quizid' => $structure->get_quizid(),
1133                         'ajaxurl' => $config->sectionurl,
1134                         'config' => $config,
1135                 )), null, true);
1137         $this->page->requires->yui_module('moodle-mod_quiz-dragdrop', 'M.mod_quiz.init_resource_dragdrop',
1138                 array(array(
1139                         'courseid' => $structure,
1140                         'quizid' => $structure->get_quizid(),
1141                         'ajaxurl' => $config->resourceurl,
1142                         'config' => $config,
1143                 )), null, true);
1145         // Require various strings for the command toolbox.
1146         $this->page->requires->strings_for_js(array(
1147                 'clicktohideshow',
1148                 'deletechecktype',
1149                 'deletechecktypename',
1150                 'edittitle',
1151                 'edittitleinstructions',
1152                 'emptydragdropregion',
1153                 'hide',
1154                 'markedthistopic',
1155                 'markthistopic',
1156                 'move',
1157                 'movecontent',
1158                 'moveleft',
1159                 'movesection',
1160                 'page',
1161                 'question',
1162                 'selectall',
1163                 'show',
1164                 'tocontent',
1165         ), 'moodle');
1167         $this->page->requires->strings_for_js(array(
1168                 'addpagebreak',
1169                 'confirmremovesectionheading',
1170                 'confirmremovequestion',
1171                 'dragtoafter',
1172                 'dragtostart',
1173                 'numquestionsx',
1174                 'sectionheadingedit',
1175                 'sectionheadingremove',
1176                 'removepagebreak',
1177                 'questiondependencyadd',
1178                 'questiondependencyfree',
1179                 'questiondependencyremove',
1180                 'questiondependsonprevious',
1181         ), 'quiz');
1183         foreach (\question_bank::get_all_qtypes() as $qtype => $notused) {
1184             $this->page->requires->string_for_js('pluginname', 'qtype_' . $qtype);
1185         }
1187         return true;
1188     }
1190     /**
1191      * HTML for a page, with ids stripped, so it can be used as a javascript template.
1192      *
1193      * @param structure $structure object containing the structure of the quiz.
1194      * @param \question_edit_contexts $contexts the relevant question bank contexts.
1195      * @param array $pagevars the variables from {@link \question_edit_setup()}.
1196      * @param \moodle_url $pageurl the canonical URL of this page.
1197      * @return string HTML for a new page.
1198      */
1199     protected function new_page_template(structure $structure,
1200             \question_edit_contexts $contexts, array $pagevars, \moodle_url $pageurl) {
1201         if (!$structure->has_questions()) {
1202             return '';
1203         }
1205         $pagehtml = $this->page_row($structure, 1, $contexts, $pagevars, $pageurl);
1207         // Normalise the page number.
1208         $pagenumber = $structure->get_page_number_for_slot(1);
1209         $strcontexts = array();
1210         $strcontexts[] = 'page-';
1211         $strcontexts[] = get_string('page') . ' ';
1212         $strcontexts[] = 'addonpage%3D';
1213         $strcontexts[] = 'addonpage=';
1214         $strcontexts[] = 'addonpage="';
1215         $strcontexts[] = get_string('addquestionfrombanktopage', 'quiz', '');
1216         $strcontexts[] = 'data-addonpage%3D';
1217         $strcontexts[] = 'action-menu-';
1219         foreach ($strcontexts as $strcontext) {
1220             $pagehtml = str_replace($strcontext . $pagenumber, $strcontext . '%%PAGENUMBER%%', $pagehtml);
1221         }
1223         return $pagehtml;
1224     }
1226     /**
1227      * HTML for a page, with ids stripped, so it can be used as a javascript template.
1228      *
1229      * @param structure $structure object containing the structure of the quiz.
1230      * @return string HTML for a new icon
1231      */
1232     protected function add_page_icon_template(structure $structure) {
1234         if (!$structure->has_questions()) {
1235             return '';
1236         }
1238         $html = $this->page_split_join_button($structure, 1);
1239         return str_replace('&amp;slot=1&amp;', '&amp;slot=%%SLOT%%&amp;', $html);
1240     }
1242     /**
1243      * Return the contents of the question bank, to be displayed in the question-bank pop-up.
1244      *
1245      * @param \mod_quiz\question\bank\custom_view $questionbank the question bank view object.
1246      * @param array $pagevars the variables from {@link \question_edit_setup()}.
1247      * @return string HTML to output / send back in response to an AJAX request.
1248      */
1249     public function question_bank_contents(\mod_quiz\question\bank\custom_view $questionbank, array $pagevars) {
1251         $qbank = $questionbank->render('editq', $pagevars['qpage'], $pagevars['qperpage'],
1252                 $pagevars['cat'], $pagevars['recurse'], $pagevars['showhidden'], $pagevars['qbshowtext']);
1253         return html_writer::div(html_writer::div($qbank, 'bd'), 'questionbankformforpopup');
1254     }