fb4808cafd4828008ac24f6d3e3af2052c7584e0
[moodle.git] / lib / outputrenderers.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  * Classes for rendering HTML output for Moodle.
19  *
20  * Please see {@link http://docs.moodle.org/en/Developement:How_Moodle_outputs_HTML}
21  * for an overview.
22  *
23  * Included in this file are the primary renderer classes:
24  *     - renderer_base:         The renderer outline class that all renderers
25  *                              should inherit from.
26  *     - core_renderer:         The standard HTML renderer.
27  *     - core_renderer_cli:     An adaption of the standard renderer for CLI scripts.
28  *     - core_renderer_ajax:    An adaption of the standard renderer for AJAX scripts.
29  *     - plugin_renderer_base:  A renderer class that should be extended by all
30  *                              plugin renderers.
31  *
32  * @package core
33  * @category output
34  * @copyright  2009 Tim Hunt
35  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
36  */
38 defined('MOODLE_INTERNAL') || die();
40 /**
41  * Simple base class for Moodle renderers.
42  *
43  * Tracks the xhtml_container_stack to use, which is passed in in the constructor.
44  *
45  * Also has methods to facilitate generating HTML output.
46  *
47  * @copyright 2009 Tim Hunt
48  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
49  * @since Moodle 2.0
50  * @package core
51  * @category output
52  */
53 class renderer_base {
54     /**
55      * @var xhtml_container_stack The xhtml_container_stack to use.
56      */
57     protected $opencontainers;
59     /**
60      * @var moodle_page The Moodle page the renderer has been created to assist with.
61      */
62     protected $page;
64     /**
65      * @var string The requested rendering target.
66      */
67     protected $target;
69     /**
70      * Constructor
71      *
72      * The constructor takes two arguments. The first is the page that the renderer
73      * has been created to assist with, and the second is the target.
74      * The target is an additional identifier that can be used to load different
75      * renderers for different options.
76      *
77      * @param moodle_page $page the page we are doing output for.
78      * @param string $target one of rendering target constants
79      */
80     public function __construct(moodle_page $page, $target) {
81         $this->opencontainers = $page->opencontainers;
82         $this->page = $page;
83         $this->target = $target;
84     }
86     /**
87      * Returns rendered widget.
88      *
89      * The provided widget needs to be an object that extends the renderable
90      * interface.
91      * If will then be rendered by a method based upon the classname for the widget.
92      * For instance a widget of class `crazywidget` will be rendered by a protected
93      * render_crazywidget method of this renderer.
94      *
95      * @param renderable $widget instance with renderable interface
96      * @return string
97      */
98     public function render(renderable $widget) {
99         $rendermethod = 'render_'.get_class($widget);
100         if (method_exists($this, $rendermethod)) {
101             return $this->$rendermethod($widget);
102         }
103         throw new coding_exception('Can not render widget, renderer method ('.$rendermethod.') not found.');
104     }
106     /**
107      * Adds a JS action for the element with the provided id.
108      *
109      * This method adds a JS event for the provided component action to the page
110      * and then returns the id that the event has been attached to.
111      * If no id has been provided then a new ID is generated by {@link html_writer::random_id()}
112      *
113      * @param component_action $action
114      * @param string $id
115      * @return string id of element, either original submitted or random new if not supplied
116      */
117     public function add_action_handler(component_action $action, $id = null) {
118         if (!$id) {
119             $id = html_writer::random_id($action->event);
120         }
121         $this->page->requires->event_handler("#$id", $action->event, $action->jsfunction, $action->jsfunctionargs);
122         return $id;
123     }
125     /**
126      * Returns true is output has already started, and false if not.
127      *
128      * @return boolean true if the header has been printed.
129      */
130     public function has_started() {
131         return $this->page->state >= moodle_page::STATE_IN_BODY;
132     }
134     /**
135      * Given an array or space-separated list of classes, prepares and returns the HTML class attribute value
136      *
137      * @param mixed $classes Space-separated string or array of classes
138      * @return string HTML class attribute value
139      */
140     public static function prepare_classes($classes) {
141         if (is_array($classes)) {
142             return implode(' ', array_unique($classes));
143         }
144         return $classes;
145     }
147     /**
148      * Return the moodle_url for an image.
149      *
150      * The exact image location and extension is determined
151      * automatically by searching for gif|png|jpg|jpeg, please
152      * note there can not be diferent images with the different
153      * extension. The imagename is for historical reasons
154      * a relative path name, it may be changed later for core
155      * images. It is recommended to not use subdirectories
156      * in plugin and theme pix directories.
157      *
158      * There are three types of images:
159      * 1/ theme images  - stored in theme/mytheme/pix/,
160      *                    use component 'theme'
161      * 2/ core images   - stored in /pix/,
162      *                    overridden via theme/mytheme/pix_core/
163      * 3/ plugin images - stored in mod/mymodule/pix,
164      *                    overridden via theme/mytheme/pix_plugins/mod/mymodule/,
165      *                    example: pix_url('comment', 'mod_glossary')
166      *
167      * @param string $imagename the pathname of the image
168      * @param string $component full plugin name (aka component) or 'theme'
169      * @return moodle_url
170      */
171     public function pix_url($imagename, $component = 'moodle') {
172         return $this->page->theme->pix_url($imagename, $component);
173     }
177 /**
178  * Basis for all plugin renderers.
179  *
180  * @copyright Petr Skoda (skodak)
181  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
182  * @since Moodle 2.0
183  * @package core
184  * @category output
185  */
186 class plugin_renderer_base extends renderer_base {
188     /**
189      * @var renderer_base|core_renderer A reference to the current renderer.
190      * The renderer provided here will be determined by the page but will in 90%
191      * of cases by the {@link core_renderer}
192      */
193     protected $output;
195     /**
196      * Constructor method, calls the parent constructor
197      *
198      * @param moodle_page $page
199      * @param string $target one of rendering target constants
200      */
201     public function __construct(moodle_page $page, $target) {
202         $this->output = $page->get_renderer('core', null, $target);
203         parent::__construct($page, $target);
204     }
206     /**
207      * Renders the provided widget and returns the HTML to display it.
208      *
209      * @param renderable $widget instance with renderable interface
210      * @return string
211      */
212     public function render(renderable $widget) {
213         $rendermethod = 'render_'.get_class($widget);
214         if (method_exists($this, $rendermethod)) {
215             return $this->$rendermethod($widget);
216         }
217         // pass to core renderer if method not found here
218         return $this->output->render($widget);
219     }
221     /**
222      * Magic method used to pass calls otherwise meant for the standard renderer
223      * to it to ensure we don't go causing unnecessary grief.
224      *
225      * @param string $method
226      * @param array $arguments
227      * @return mixed
228      */
229     public function __call($method, $arguments) {
230         if (method_exists('renderer_base', $method)) {
231             throw new coding_exception('Protected method called against '.get_class($this).' :: '.$method);
232         }
233         if (method_exists($this->output, $method)) {
234             return call_user_func_array(array($this->output, $method), $arguments);
235         } else {
236             throw new coding_exception('Unknown method called against '.get_class($this).' :: '.$method);
237         }
238     }
242 /**
243  * The standard implementation of the core_renderer interface.
244  *
245  * @copyright 2009 Tim Hunt
246  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
247  * @since Moodle 2.0
248  * @package core
249  * @category output
250  */
251 class core_renderer extends renderer_base {
252     /**
253      * Do NOT use, please use <?php echo $OUTPUT->main_content() ?>
254      * in layout files instead.
255      * @deprecated
256      * @var string used in {@link core_renderer::header()}.
257      */
258     const MAIN_CONTENT_TOKEN = '[MAIN CONTENT GOES HERE]';
260     /**
261      * @var string Used to pass information from {@link core_renderer::doctype()} to
262      * {@link core_renderer::standard_head_html()}.
263      */
264     protected $contenttype;
266     /**
267      * @var string Used by {@link core_renderer::redirect_message()} method to communicate
268      * with {@link core_renderer::header()}.
269      */
270     protected $metarefreshtag = '';
272     /**
273      * @var string Unique token for the closing HTML
274      */
275     protected $unique_end_html_token;
277     /**
278      * @var string Unique token for performance information
279      */
280     protected $unique_performance_info_token;
282     /**
283      * @var string Unique token for the main content.
284      */
285     protected $unique_main_content_token;
287     /**
288      * Constructor
289      *
290      * @param moodle_page $page the page we are doing output for.
291      * @param string $target one of rendering target constants
292      */
293     public function __construct(moodle_page $page, $target) {
294         $this->opencontainers = $page->opencontainers;
295         $this->page = $page;
296         $this->target = $target;
298         $this->unique_end_html_token = '%%ENDHTML-'.sesskey().'%%';
299         $this->unique_performance_info_token = '%%PERFORMANCEINFO-'.sesskey().'%%';
300         $this->unique_main_content_token = '[MAIN CONTENT GOES HERE - '.sesskey().']';
301     }
303     /**
304      * Get the DOCTYPE declaration that should be used with this page. Designed to
305      * be called in theme layout.php files.
306      *
307      * @return string the DOCTYPE declaration that should be used.
308      */
309     public function doctype() {
310         if ($this->page->theme->doctype === 'html5') {
311             $this->contenttype = 'text/html; charset=utf-8';
312             return "<!DOCTYPE html>\n";
314         } else if ($this->page->theme->doctype === 'xhtml5') {
315             $this->contenttype = 'application/xhtml+xml; charset=utf-8';
316             return "<!DOCTYPE html>\n";
318         } else {
319             // legacy xhtml 1.0
320             $this->contenttype = 'text/html; charset=utf-8';
321             return ('<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">' . "\n");
322         }
323     }
325     /**
326      * The attributes that should be added to the <html> tag. Designed to
327      * be called in theme layout.php files.
328      *
329      * @return string HTML fragment.
330      */
331     public function htmlattributes() {
332         $return = get_html_lang(true);
333         if ($this->page->theme->doctype !== 'html5') {
334             $return .= ' xmlns="http://www.w3.org/1999/xhtml"';
335         }
336         return $return;
337     }
339     /**
340      * The standard tags (meta tags, links to stylesheets and JavaScript, etc.)
341      * that should be included in the <head> tag. Designed to be called in theme
342      * layout.php files.
343      *
344      * @return string HTML fragment.
345      */
346     public function standard_head_html() {
347         global $CFG, $SESSION;
348         $output = '';
349         $output .= '<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />' . "\n";
350         $output .= '<meta name="keywords" content="moodle, ' . $this->page->title . '" />' . "\n";
351         if (!$this->page->cacheable) {
352             $output .= '<meta http-equiv="pragma" content="no-cache" />' . "\n";
353             $output .= '<meta http-equiv="expires" content="0" />' . "\n";
354         }
355         // This is only set by the {@link redirect()} method
356         $output .= $this->metarefreshtag;
358         // Check if a periodic refresh delay has been set and make sure we arn't
359         // already meta refreshing
360         if ($this->metarefreshtag=='' && $this->page->periodicrefreshdelay!==null) {
361             $output .= '<meta http-equiv="refresh" content="'.$this->page->periodicrefreshdelay.';url='.$this->page->url->out().'" />';
362         }
364         // flow player embedding support
365         $this->page->requires->js_function_call('M.util.load_flowplayer');
367         // Set up help link popups for all links with the helplinkpopup class
368         $this->page->requires->js_init_call('M.util.help_popups.setup');
370         $this->page->requires->js_function_call('setTimeout', array('fix_column_widths()', 20));
372         $focus = $this->page->focuscontrol;
373         if (!empty($focus)) {
374             if (preg_match("#forms\['([a-zA-Z0-9]+)'\].elements\['([a-zA-Z0-9]+)'\]#", $focus, $matches)) {
375                 // This is a horrifically bad way to handle focus but it is passed in
376                 // through messy formslib::moodleform
377                 $this->page->requires->js_function_call('old_onload_focus', array($matches[1], $matches[2]));
378             } else if (strpos($focus, '.')!==false) {
379                 // Old style of focus, bad way to do it
380                 debugging('This code is using the old style focus event, Please update this code to focus on an element id or the moodleform focus method.', DEBUG_DEVELOPER);
381                 $this->page->requires->js_function_call('old_onload_focus', explode('.', $focus, 2));
382             } else {
383                 // Focus element with given id
384                 $this->page->requires->js_function_call('focuscontrol', array($focus));
385             }
386         }
388         // Get the theme stylesheet - this has to be always first CSS, this loads also styles.css from all plugins;
389         // any other custom CSS can not be overridden via themes and is highly discouraged
390         $urls = $this->page->theme->css_urls($this->page);
391         foreach ($urls as $url) {
392             $this->page->requires->css_theme($url);
393         }
395         // Get the theme javascript head and footer
396         if ($jsurl = $this->page->theme->javascript_url(true)) {
397             $this->page->requires->js($jsurl, true);
398         }
399         if ($jsurl = $this->page->theme->javascript_url(false)) {
400             $this->page->requires->js($jsurl);
401         }
403         // Get any HTML from the page_requirements_manager.
404         $output .= $this->page->requires->get_head_code($this->page, $this);
406         // List alternate versions.
407         foreach ($this->page->alternateversions as $type => $alt) {
408             $output .= html_writer::empty_tag('link', array('rel' => 'alternate',
409                     'type' => $type, 'title' => $alt->title, 'href' => $alt->url));
410         }
412         if (!empty($CFG->additionalhtmlhead)) {
413             $output .= "\n".$CFG->additionalhtmlhead;
414         }
416         return $output;
417     }
419     /**
420      * The standard tags (typically skip links) that should be output just inside
421      * the start of the <body> tag. Designed to be called in theme layout.php files.
422      *
423      * @return string HTML fragment.
424      */
425     public function standard_top_of_body_html() {
426         global $CFG;
427         $output = $this->page->requires->get_top_of_body_code();
428         if (!empty($CFG->additionalhtmltopofbody)) {
429             $output .= "\n".$CFG->additionalhtmltopofbody;
430         }
431         $output .= $this->maintenance_warning();
432         return $output;
433     }
435     /**
436      * Scheduled maintenance warning message.
437      *
438      * Note: This is a nasty hack to display maintenance notice, this should be moved
439      *       to some general notification area once we have it.
440      *
441      * @return string
442      */
443     public function maintenance_warning() {
444         global $CFG;
446         $output = '';
447         if (isset($CFG->maintenance_later) and $CFG->maintenance_later > time()) {
448             $output .= $this->box_start('errorbox maintenancewarning');
449             $output .= get_string('maintenancemodeisscheduled', 'admin', (int)(($CFG->maintenance_later-time())/60));
450             $output .= $this->box_end();
451         }
452         return $output;
453     }
455     /**
456      * The standard tags (typically performance information and validation links,
457      * if we are in developer debug mode) that should be output in the footer area
458      * of the page. Designed to be called in theme layout.php files.
459      *
460      * @return string HTML fragment.
461      */
462     public function standard_footer_html() {
463         global $CFG, $SCRIPT;
465         // This function is normally called from a layout.php file in {@link core_renderer::header()}
466         // but some of the content won't be known until later, so we return a placeholder
467         // for now. This will be replaced with the real content in {@link core_renderer::footer()}.
468         $output = $this->unique_performance_info_token;
469         if ($this->page->devicetypeinuse == 'legacy') {
470             // The legacy theme is in use print the notification
471             $output .= html_writer::tag('div', get_string('legacythemeinuse'), array('class'=>'legacythemeinuse'));
472         }
474         // Get links to switch device types (only shown for users not on a default device)
475         $output .= $this->theme_switch_links();
477         if (!empty($CFG->debugpageinfo)) {
478             $output .= '<div class="performanceinfo pageinfo">This page is: ' . $this->page->debug_summary() . '</div>';
479         }
480         if (debugging(null, DEBUG_DEVELOPER) and has_capability('moodle/site:config', context_system::instance())) {  // Only in developer mode
481             // Add link to profiling report if necessary
482             if (function_exists('profiling_is_running') && profiling_is_running()) {
483                 $txt = get_string('profiledscript', 'admin');
484                 $title = get_string('profiledscriptview', 'admin');
485                 $url = $CFG->wwwroot . '/admin/tool/profiling/index.php?script=' . urlencode($SCRIPT);
486                 $link= '<a title="' . $title . '" href="' . $url . '">' . $txt . '</a>';
487                 $output .= '<div class="profilingfooter">' . $link . '</div>';
488             }
489             $output .= '<div class="purgecaches"><a href="'.$CFG->wwwroot.'/'.$CFG->admin.'/purgecaches.php?confirm=1&amp;sesskey='.sesskey().'">'.get_string('purgecaches', 'admin').'</a></div>';
490         }
491         if (!empty($CFG->debugvalidators)) {
492             // NOTE: this is not a nice hack, $PAGE->url is not always accurate and $FULLME neither, it is not a bug if it fails. --skodak
493             $output .= '<div class="validators"><ul>
494               <li><a href="http://validator.w3.org/check?verbose=1&amp;ss=1&amp;uri=' . urlencode(qualified_me()) . '">Validate HTML</a></li>
495               <li><a href="http://www.contentquality.com/mynewtester/cynthia.exe?rptmode=-1&amp;url1=' . urlencode(qualified_me()) . '">Section 508 Check</a></li>
496               <li><a href="http://www.contentquality.com/mynewtester/cynthia.exe?rptmode=0&amp;warnp2n3e=1&amp;url1=' . urlencode(qualified_me()) . '">WCAG 1 (2,3) Check</a></li>
497             </ul></div>';
498         }
499         if (!empty($CFG->additionalhtmlfooter)) {
500             $output .= "\n".$CFG->additionalhtmlfooter;
501         }
502         return $output;
503     }
505     /**
506      * Returns standard main content placeholder.
507      * Designed to be called in theme layout.php files.
508      *
509      * @return string HTML fragment.
510      */
511     public function main_content() {
512         // This is here because it is the only place we can inject the "main" role over the entire main content area
513         // without requiring all theme's to manually do it, and without creating yet another thing people need to
514         // remember in the theme.
515         // This is an unfortunate hack. DO NO EVER add anything more here.
516         // DO NOT add classes.
517         // DO NOT add an id.
518         return '<div role="main">'.$this->unique_main_content_token.'</div>';
519     }
521     /**
522      * The standard tags (typically script tags that are not needed earlier) that
523      * should be output after everything else, . Designed to be called in theme layout.php files.
524      *
525      * @return string HTML fragment.
526      */
527     public function standard_end_of_body_html() {
528         // This function is normally called from a layout.php file in {@link core_renderer::header()}
529         // but some of the content won't be known until later, so we return a placeholder
530         // for now. This will be replaced with the real content in {@link core_renderer::footer()}.
531         return $this->unique_end_html_token;
532     }
534     /**
535      * Return the standard string that says whether you are logged in (and switched
536      * roles/logged in as another user).
537      * @param bool $withlinks if false, then don't include any links in the HTML produced.
538      * If not set, the default is the nologinlinks option from the theme config.php file,
539      * and if that is not set, then links are included.
540      * @return string HTML fragment.
541      */
542     public function login_info($withlinks = null) {
543         global $USER, $CFG, $DB, $SESSION;
545         if (during_initial_install()) {
546             return '';
547         }
549         if (is_null($withlinks)) {
550             $withlinks = empty($this->page->layout_options['nologinlinks']);
551         }
553         $loginpage = ((string)$this->page->url === get_login_url());
554         $course = $this->page->course;
555         if (session_is_loggedinas()) {
556             $realuser = session_get_realuser();
557             $fullname = fullname($realuser, true);
558             if ($withlinks) {
559                 $realuserinfo = " [<a href=\"$CFG->wwwroot/course/loginas.php?id=$course->id&amp;sesskey=".sesskey()."\">$fullname</a>] ";
560             } else {
561                 $realuserinfo = " [$fullname] ";
562             }
563         } else {
564             $realuserinfo = '';
565         }
567         $loginurl = get_login_url();
569         if (empty($course->id)) {
570             // $course->id is not defined during installation
571             return '';
572         } else if (isloggedin()) {
573             $context = context_course::instance($course->id);
575             $fullname = fullname($USER, true);
576             // Since Moodle 2.0 this link always goes to the public profile page (not the course profile page)
577             if ($withlinks) {
578                 $username = "<a href=\"$CFG->wwwroot/user/profile.php?id=$USER->id\">$fullname</a>";
579             } else {
580                 $username = $fullname;
581             }
582             if (is_mnet_remote_user($USER) and $idprovider = $DB->get_record('mnet_host', array('id'=>$USER->mnethostid))) {
583                 if ($withlinks) {
584                     $username .= " from <a href=\"{$idprovider->wwwroot}\">{$idprovider->name}</a>";
585                 } else {
586                     $username .= " from {$idprovider->name}";
587                 }
588             }
589             if (isguestuser()) {
590                 $loggedinas = $realuserinfo.get_string('loggedinasguest');
591                 if (!$loginpage && $withlinks) {
592                     $loggedinas .= " (<a href=\"$loginurl\">".get_string('login').'</a>)';
593                 }
594             } else if (is_role_switched($course->id)) { // Has switched roles
595                 $rolename = '';
596                 if ($role = $DB->get_record('role', array('id'=>$USER->access['rsw'][$context->path]))) {
597                     $rolename = ': '.format_string($role->name);
598                 }
599                 $loggedinas = get_string('loggedinas', 'moodle', $username).$rolename;
600                 if ($withlinks) {
601                     $url = new moodle_url('/course/switchrole.php', array('id'=>$course->id,'sesskey'=>sesskey(), 'switchrole'=>0, 'returnurl'=>$this->page->url->out_as_local_url(false)));
602                     $loggedinas .= '('.html_writer::tag('a', get_string('switchrolereturn'), array('href'=>$url)).')';
603                 }
604             } else {
605                 $loggedinas = $realuserinfo.get_string('loggedinas', 'moodle', $username);
606                 if ($withlinks) {
607                     $loggedinas .= " (<a href=\"$CFG->wwwroot/login/logout.php?sesskey=".sesskey()."\">".get_string('logout').'</a>)';
608                 }
609             }
610         } else {
611             $loggedinas = get_string('loggedinnot', 'moodle');
612             if (!$loginpage && $withlinks) {
613                 $loggedinas .= " (<a href=\"$loginurl\">".get_string('login').'</a>)';
614             }
615         }
617         $loggedinas = '<div class="logininfo">'.$loggedinas.'</div>';
619         if (isset($SESSION->justloggedin)) {
620             unset($SESSION->justloggedin);
621             if (!empty($CFG->displayloginfailures)) {
622                 if (!isguestuser()) {
623                     if ($count = count_login_failures($CFG->displayloginfailures, $USER->username, $USER->lastlogin)) {
624                         $loggedinas .= '&nbsp;<div class="loginfailures">';
625                         if (empty($count->accounts)) {
626                             $loggedinas .= get_string('failedloginattempts', '', $count);
627                         } else {
628                             $loggedinas .= get_string('failedloginattemptsall', '', $count);
629                         }
630                         if (file_exists("$CFG->dirroot/report/log/index.php") and has_capability('report/log:view', context_system::instance())) {
631                             $loggedinas .= ' (<a href="'.$CFG->wwwroot.'/report/log/index.php'.
632                                                  '?chooselog=1&amp;id=1&amp;modid=site_errors">'.get_string('logs').'</a>)';
633                         }
634                         $loggedinas .= '</div>';
635                     }
636                 }
637             }
638         }
640         return $loggedinas;
641     }
643     /**
644      * Return the 'back' link that normally appears in the footer.
645      *
646      * @return string HTML fragment.
647      */
648     public function home_link() {
649         global $CFG, $SITE;
651         if ($this->page->pagetype == 'site-index') {
652             // Special case for site home page - please do not remove
653             return '<div class="sitelink">' .
654                    '<a title="Moodle" href="http://moodle.org/">' .
655                    '<img style="width:100px;height:30px" src="' . $this->pix_url('moodlelogo') . '" alt="moodlelogo" /></a></div>';
657         } else if (!empty($CFG->target_release) && $CFG->target_release != $CFG->release) {
658             // Special case for during install/upgrade.
659             return '<div class="sitelink">'.
660                    '<a title="Moodle" href="http://docs.moodle.org/en/Administrator_documentation" onclick="this.target=\'_blank\'">' .
661                    '<img style="width:100px;height:30px" src="' . $this->pix_url('moodlelogo') . '" alt="moodlelogo" /></a></div>';
663         } else if ($this->page->course->id == $SITE->id || strpos($this->page->pagetype, 'course-view') === 0) {
664             return '<div class="homelink"><a href="' . $CFG->wwwroot . '/">' .
665                     get_string('home') . '</a></div>';
667         } else {
668             return '<div class="homelink"><a href="' . $CFG->wwwroot . '/course/view.php?id=' . $this->page->course->id . '">' .
669                     format_string($this->page->course->shortname, true, array('context' => $this->page->context)) . '</a></div>';
670         }
671     }
673     /**
674      * Redirects the user by any means possible given the current state
675      *
676      * This function should not be called directly, it should always be called using
677      * the redirect function in lib/weblib.php
678      *
679      * The redirect function should really only be called before page output has started
680      * however it will allow itself to be called during the state STATE_IN_BODY
681      *
682      * @param string $encodedurl The URL to send to encoded if required
683      * @param string $message The message to display to the user if any
684      * @param int $delay The delay before redirecting a user, if $message has been
685      *         set this is a requirement and defaults to 3, set to 0 no delay
686      * @param boolean $debugdisableredirect this redirect has been disabled for
687      *         debugging purposes. Display a message that explains, and don't
688      *         trigger the redirect.
689      * @return string The HTML to display to the user before dying, may contain
690      *         meta refresh, javascript refresh, and may have set header redirects
691      */
692     public function redirect_message($encodedurl, $message, $delay, $debugdisableredirect) {
693         global $CFG;
694         $url = str_replace('&amp;', '&', $encodedurl);
696         switch ($this->page->state) {
697             case moodle_page::STATE_BEFORE_HEADER :
698                 // No output yet it is safe to delivery the full arsenal of redirect methods
699                 if (!$debugdisableredirect) {
700                     // Don't use exactly the same time here, it can cause problems when both redirects fire at the same time.
701                     $this->metarefreshtag = '<meta http-equiv="refresh" content="'. $delay .'; url='. $encodedurl .'" />'."\n";
702                     $this->page->requires->js_function_call('document.location.replace', array($url), false, ($delay + 3));
703                 }
704                 $output = $this->header();
705                 break;
706             case moodle_page::STATE_PRINTING_HEADER :
707                 // We should hopefully never get here
708                 throw new coding_exception('You cannot redirect while printing the page header');
709                 break;
710             case moodle_page::STATE_IN_BODY :
711                 // We really shouldn't be here but we can deal with this
712                 debugging("You should really redirect before you start page output");
713                 if (!$debugdisableredirect) {
714                     $this->page->requires->js_function_call('document.location.replace', array($url), false, $delay);
715                 }
716                 $output = $this->opencontainers->pop_all_but_last();
717                 break;
718             case moodle_page::STATE_DONE :
719                 // Too late to be calling redirect now
720                 throw new coding_exception('You cannot redirect after the entire page has been generated');
721                 break;
722         }
723         $output .= $this->notification($message, 'redirectmessage');
724         $output .= '<div class="continuebutton">(<a href="'. $encodedurl .'">'. get_string('continue') .'</a>)</div>';
725         if ($debugdisableredirect) {
726             $output .= '<p><strong>Error output, so disabling automatic redirect.</strong></p>';
727         }
728         $output .= $this->footer();
729         return $output;
730     }
732     /**
733      * Start output by sending the HTTP headers, and printing the HTML <head>
734      * and the start of the <body>.
735      *
736      * To control what is printed, you should set properties on $PAGE. If you
737      * are familiar with the old {@link print_header()} function from Moodle 1.9
738      * you will find that there are properties on $PAGE that correspond to most
739      * of the old parameters to could be passed to print_header.
740      *
741      * Not that, in due course, the remaining $navigation, $menu parameters here
742      * will be replaced by more properties of $PAGE, but that is still to do.
743      *
744      * @return string HTML that you must output this, preferably immediately.
745      */
746     public function header() {
747         global $USER, $CFG;
749         if (session_is_loggedinas()) {
750             $this->page->add_body_class('userloggedinas');
751         }
753         $this->page->set_state(moodle_page::STATE_PRINTING_HEADER);
755         // Find the appropriate page layout file, based on $this->page->pagelayout.
756         $layoutfile = $this->page->theme->layout_file($this->page->pagelayout);
757         // Render the layout using the layout file.
758         $rendered = $this->render_page_layout($layoutfile);
760         // Slice the rendered output into header and footer.
761         $cutpos = strpos($rendered, $this->unique_main_content_token);
762         if ($cutpos === false) {
763             $cutpos = strpos($rendered, self::MAIN_CONTENT_TOKEN);
764             $token = self::MAIN_CONTENT_TOKEN;
765         } else {
766             $token = $this->unique_main_content_token;
767         }
769         if ($cutpos === false) {
770             throw new coding_exception('page layout file ' . $layoutfile . ' does not contain the main content placeholder, please include "<?php echo $OUTPUT->main_content() ?>" in theme layout file.');
771         }
772         $header = substr($rendered, 0, $cutpos);
773         $footer = substr($rendered, $cutpos + strlen($token));
775         if (empty($this->contenttype)) {
776             debugging('The page layout file did not call $OUTPUT->doctype()');
777             $header = $this->doctype() . $header;
778         }
780         // If this theme version is below 2.4 release and this is a course view page
781         if ((!isset($this->page->theme->settings->version) || $this->page->theme->settings->version < 2012101500) &&
782                 $this->page->pagelayout === 'course' && $this->page->url->compare(new moodle_url('/course/view.php'), URL_MATCH_BASE)) {
783             // check if course content header/footer have not been output during render of theme layout
784             $coursecontentheader = $this->course_content_header(true);
785             $coursecontentfooter = $this->course_content_footer(true);
786             if (!empty($coursecontentheader)) {
787                 // display debug message and add header and footer right above and below main content
788                 // Please note that course header and footer (to be displayed above and below the whole page)
789                 // are not displayed in this case at all.
790                 // Besides the content header and footer are not displayed on any other course page
791                 debugging('The current theme is not optimised for 2.4, the course-specific header and footer defined in course format will not be output', DEBUG_DEVELOPER);
792                 $header .= $coursecontentheader;
793                 $footer = $coursecontentfooter. $footer;
794             }
795         }
797         send_headers($this->contenttype, $this->page->cacheable);
799         $this->opencontainers->push('header/footer', $footer);
800         $this->page->set_state(moodle_page::STATE_IN_BODY);
802         return $header . $this->skip_link_target('maincontent');
803     }
805     /**
806      * Renders and outputs the page layout file.
807      *
808      * This is done by preparing the normal globals available to a script, and
809      * then including the layout file provided by the current theme for the
810      * requested layout.
811      *
812      * @param string $layoutfile The name of the layout file
813      * @return string HTML code
814      */
815     protected function render_page_layout($layoutfile) {
816         global $CFG, $SITE, $USER;
817         // The next lines are a bit tricky. The point is, here we are in a method
818         // of a renderer class, and this object may, or may not, be the same as
819         // the global $OUTPUT object. When rendering the page layout file, we want to use
820         // this object. However, people writing Moodle code expect the current
821         // renderer to be called $OUTPUT, not $this, so define a variable called
822         // $OUTPUT pointing at $this. The same comment applies to $PAGE and $COURSE.
823         $OUTPUT = $this;
824         $PAGE = $this->page;
825         $COURSE = $this->page->course;
827         ob_start();
828         include($layoutfile);
829         $rendered = ob_get_contents();
830         ob_end_clean();
831         return $rendered;
832     }
834     /**
835      * Outputs the page's footer
836      *
837      * @return string HTML fragment
838      */
839     public function footer() {
840         global $CFG, $DB;
842         $output = $this->container_end_all(true);
844         $footer = $this->opencontainers->pop('header/footer');
846         if (debugging() and $DB and $DB->is_transaction_started()) {
847             // TODO: MDL-20625 print warning - transaction will be rolled back
848         }
850         // Provide some performance info if required
851         $performanceinfo = '';
852         if (defined('MDL_PERF') || (!empty($CFG->perfdebug) and $CFG->perfdebug > 7)) {
853             $perf = get_performance_info();
854             if (defined('MDL_PERFTOLOG') && !function_exists('register_shutdown_function')) {
855                 error_log("PERF: " . $perf['txt']);
856             }
857             if (defined('MDL_PERFTOFOOT') || debugging() || $CFG->perfdebug > 7) {
858                 $performanceinfo = $perf['html'];
859             }
860         }
861         $footer = str_replace($this->unique_performance_info_token, $performanceinfo, $footer);
863         $footer = str_replace($this->unique_end_html_token, $this->page->requires->get_end_code(), $footer);
865         $this->page->set_state(moodle_page::STATE_DONE);
867         return $output . $footer;
868     }
870     /**
871      * Close all but the last open container. This is useful in places like error
872      * handling, where you want to close all the open containers (apart from <body>)
873      * before outputting the error message.
874      *
875      * @param bool $shouldbenone assert that the stack should be empty now - causes a
876      *      developer debug warning if it isn't.
877      * @return string the HTML required to close any open containers inside <body>.
878      */
879     public function container_end_all($shouldbenone = false) {
880         return $this->opencontainers->pop_all_but_last($shouldbenone);
881     }
883     /**
884      * Returns course-specific information to be output immediately above content on any course page
885      * (for the current course)
886      *
887      * @param bool $onlyifnotcalledbefore output content only if it has not been output before
888      * @return string
889      */
890     public function course_content_header($onlyifnotcalledbefore = false) {
891         global $CFG;
892         if ($this->page->course->id == SITEID) {
893             // return immediately and do not include /course/lib.php if not necessary
894             return '';
895         }
896         static $functioncalled = false;
897         if ($functioncalled && $onlyifnotcalledbefore) {
898             // we have already output the content header
899             return '';
900         }
901         require_once($CFG->dirroot.'/course/lib.php');
902         $functioncalled = true;
903         $courseformat = course_get_format($this->page->course);
904         if (($obj = $courseformat->course_content_header()) !== null) {
905             return $courseformat->get_renderer($this->page)->render($obj);
906         }
907         return '';
908     }
910     /**
911      * Returns course-specific information to be output immediately below content on any course page
912      * (for the current course)
913      *
914      * @param bool $onlyifnotcalledbefore output content only if it has not been output before
915      * @return string
916      */
917     public function course_content_footer($onlyifnotcalledbefore = false) {
918         global $CFG;
919         if ($this->page->course->id == SITEID) {
920             // return immediately and do not include /course/lib.php if not necessary
921             return '';
922         }
923         static $functioncalled = false;
924         if ($functioncalled && $onlyifnotcalledbefore) {
925             // we have already output the content footer
926             return '';
927         }
928         $functioncalled = true;
929         require_once($CFG->dirroot.'/course/lib.php');
930         $courseformat = course_get_format($this->page->course);
931         if (($obj = $courseformat->course_content_footer()) !== null) {
932             return $courseformat->get_renderer($this->page)->render($obj);
933         }
934         return '';
935     }
937     /**
938      * Returns course-specific information to be output on any course page in the header area
939      * (for the current course)
940      *
941      * @return string
942      */
943     public function course_header() {
944         global $CFG;
945         if ($this->page->course->id == SITEID) {
946             // return immediately and do not include /course/lib.php if not necessary
947             return '';
948         }
949         require_once($CFG->dirroot.'/course/lib.php');
950         $courseformat = course_get_format($this->page->course);
951         if (($obj = $courseformat->course_header()) !== null) {
952             return $courseformat->get_renderer($this->page)->render($obj);
953         }
954         return '';
955     }
957     /**
958      * Returns course-specific information to be output on any course page in the footer area
959      * (for the current course)
960      *
961      * @return string
962      */
963     public function course_footer() {
964         global $CFG;
965         if ($this->page->course->id == SITEID) {
966             // return immediately and do not include /course/lib.php if not necessary
967             return '';
968         }
969         require_once($CFG->dirroot.'/course/lib.php');
970         $courseformat = course_get_format($this->page->course);
971         if (($obj = $courseformat->course_footer()) !== null) {
972             return $courseformat->get_renderer($this->page)->render($obj);
973         }
974         return '';
975     }
977     /**
978      * Returns lang menu or '', this method also checks forcing of languages in courses.
979      *
980      * @return string The lang menu HTML or empty string
981      */
982     public function lang_menu() {
983         global $CFG;
985         if (empty($CFG->langmenu)) {
986             return '';
987         }
989         if ($this->page->course != SITEID and !empty($this->page->course->lang)) {
990             // do not show lang menu if language forced
991             return '';
992         }
994         $currlang = current_language();
995         $langs = get_string_manager()->get_list_of_translations();
997         if (count($langs) < 2) {
998             return '';
999         }
1001         $s = new single_select($this->page->url, 'lang', $langs, $currlang, null);
1002         $s->label = get_accesshide(get_string('language'));
1003         $s->class = 'langmenu';
1004         return $this->render($s);
1005     }
1007     /**
1008      * Output the row of editing icons for a block, as defined by the controls array.
1009      *
1010      * @param array $controls an array like {@link block_contents::$controls}.
1011      * @return string HTML fragment.
1012      */
1013     public function block_controls($controls) {
1014         if (empty($controls)) {
1015             return '';
1016         }
1017         $controlshtml = array();
1018         foreach ($controls as $control) {
1019             $controlshtml[] = html_writer::tag('a',
1020                     html_writer::empty_tag('img',  array('src' => $this->pix_url($control['icon'])->out(false), 'alt' => $control['caption'])),
1021                     array('class' => 'icon ' . $control['class'],'title' => $control['caption'], 'href' => $control['url']));
1022         }
1023         return html_writer::tag('div', implode('', $controlshtml), array('class' => 'commands'));
1024     }
1026     /**
1027      * Prints a nice side block with an optional header.
1028      *
1029      * The content is described
1030      * by a {@link core_renderer::block_contents} object.
1031      *
1032      * <div id="inst{$instanceid}" class="block_{$blockname} block">
1033      *      <div class="header"></div>
1034      *      <div class="content">
1035      *          ...CONTENT...
1036      *          <div class="footer">
1037      *          </div>
1038      *      </div>
1039      *      <div class="annotation">
1040      *      </div>
1041      * </div>
1042      *
1043      * @param block_contents $bc HTML for the content
1044      * @param string $region the region the block is appearing in.
1045      * @return string the HTML to be output.
1046      */
1047     public function block(block_contents $bc, $region) {
1048         $bc = clone($bc); // Avoid messing up the object passed in.
1049         if (empty($bc->blockinstanceid) || !strip_tags($bc->title)) {
1050             $bc->collapsible = block_contents::NOT_HIDEABLE;
1051         }
1052         $skiptitle = strip_tags($bc->title);
1053         if ($bc->blockinstanceid && !empty($skiptitle)) {
1054             $bc->attributes['aria-labelledby'] = 'instance-'.$bc->blockinstanceid.'-header';
1055         } else if (!empty($bc->arialabel)) {
1056             $bc->attributes['aria-label'] = $bc->arialabel;
1057         }
1058         if ($bc->collapsible == block_contents::HIDDEN) {
1059             $bc->add_class('hidden');
1060         }
1061         if (!empty($bc->controls)) {
1062             $bc->add_class('block_with_controls');
1063         }
1066         if (empty($skiptitle)) {
1067             $output = '';
1068             $skipdest = '';
1069         } else {
1070             $output = html_writer::tag('a', get_string('skipa', 'access', $skiptitle), array('href' => '#sb-' . $bc->skipid, 'class' => 'skip-block'));
1071             $skipdest = html_writer::tag('span', '', array('id' => 'sb-' . $bc->skipid, 'class' => 'skip-block-to'));
1072         }
1074         $output .= html_writer::start_tag('div', $bc->attributes);
1076         $output .= $this->block_header($bc);
1077         $output .= $this->block_content($bc);
1079         $output .= html_writer::end_tag('div');
1081         $output .= $this->block_annotation($bc);
1083         $output .= $skipdest;
1085         $this->init_block_hider_js($bc);
1086         return $output;
1087     }
1089     /**
1090      * Produces a header for a block
1091      *
1092      * @param block_contents $bc
1093      * @return string
1094      */
1095     protected function block_header(block_contents $bc) {
1097         $title = '';
1098         if ($bc->title) {
1099             $attributes = array();
1100             if ($bc->blockinstanceid) {
1101                 $attributes['id'] = 'instance-'.$bc->blockinstanceid.'-header';
1102             }
1103             $title = html_writer::tag('h2', $bc->title, $attributes);
1104         }
1106         $controlshtml = $this->block_controls($bc->controls);
1108         $output = '';
1109         if ($title || $controlshtml) {
1110             $output .= html_writer::tag('div', html_writer::tag('div', html_writer::tag('div', '', array('class'=>'block_action')). $title . $controlshtml, array('class' => 'title')), array('class' => 'header'));
1111         }
1112         return $output;
1113     }
1115     /**
1116      * Produces the content area for a block
1117      *
1118      * @param block_contents $bc
1119      * @return string
1120      */
1121     protected function block_content(block_contents $bc) {
1122         $output = html_writer::start_tag('div', array('class' => 'content'));
1123         if (!$bc->title && !$this->block_controls($bc->controls)) {
1124             $output .= html_writer::tag('div', '', array('class'=>'block_action notitle'));
1125         }
1126         $output .= $bc->content;
1127         $output .= $this->block_footer($bc);
1128         $output .= html_writer::end_tag('div');
1130         return $output;
1131     }
1133     /**
1134      * Produces the footer for a block
1135      *
1136      * @param block_contents $bc
1137      * @return string
1138      */
1139     protected function block_footer(block_contents $bc) {
1140         $output = '';
1141         if ($bc->footer) {
1142             $output .= html_writer::tag('div', $bc->footer, array('class' => 'footer'));
1143         }
1144         return $output;
1145     }
1147     /**
1148      * Produces the annotation for a block
1149      *
1150      * @param block_contents $bc
1151      * @return string
1152      */
1153     protected function block_annotation(block_contents $bc) {
1154         $output = '';
1155         if ($bc->annotation) {
1156             $output .= html_writer::tag('div', $bc->annotation, array('class' => 'blockannotation'));
1157         }
1158         return $output;
1159     }
1161     /**
1162      * Calls the JS require function to hide a block.
1163      *
1164      * @param block_contents $bc A block_contents object
1165      */
1166     protected function init_block_hider_js(block_contents $bc) {
1167         if (!empty($bc->attributes['id']) and $bc->collapsible != block_contents::NOT_HIDEABLE) {
1168             $config = new stdClass;
1169             $config->id = $bc->attributes['id'];
1170             $config->title = strip_tags($bc->title);
1171             $config->preference = 'block' . $bc->blockinstanceid . 'hidden';
1172             $config->tooltipVisible = get_string('hideblocka', 'access', $config->title);
1173             $config->tooltipHidden = get_string('showblocka', 'access', $config->title);
1175             $this->page->requires->js_init_call('M.util.init_block_hider', array($config));
1176             user_preference_allow_ajax_update($config->preference, PARAM_BOOL);
1177         }
1178     }
1180     /**
1181      * Render the contents of a block_list.
1182      *
1183      * @param array $icons the icon for each item.
1184      * @param array $items the content of each item.
1185      * @return string HTML
1186      */
1187     public function list_block_contents($icons, $items) {
1188         $row = 0;
1189         $lis = array();
1190         foreach ($items as $key => $string) {
1191             $item = html_writer::start_tag('li', array('class' => 'r' . $row));
1192             if (!empty($icons[$key])) { //test if the content has an assigned icon
1193                 $item .= html_writer::tag('div', $icons[$key], array('class' => 'icon column c0'));
1194             }
1195             $item .= html_writer::tag('div', $string, array('class' => 'column c1'));
1196             $item .= html_writer::end_tag('li');
1197             $lis[] = $item;
1198             $row = 1 - $row; // Flip even/odd.
1199         }
1200         return html_writer::tag('ul', implode("\n", $lis), array('class' => 'unlist'));
1201     }
1203     /**
1204      * Output all the blocks in a particular region.
1205      *
1206      * @param string $region the name of a region on this page.
1207      * @return string the HTML to be output.
1208      */
1209     public function blocks_for_region($region) {
1210         $blockcontents = $this->page->blocks->get_content_for_region($region, $this);
1212         $output = '';
1213         foreach ($blockcontents as $bc) {
1214             if ($bc instanceof block_contents) {
1215                 $output .= $this->block($bc, $region);
1216             } else if ($bc instanceof block_move_target) {
1217                 $output .= $this->block_move_target($bc);
1218             } else {
1219                 throw new coding_exception('Unexpected type of thing (' . get_class($bc) . ') found in list of block contents.');
1220             }
1221         }
1222         return $output;
1223     }
1225     /**
1226      * Output a place where the block that is currently being moved can be dropped.
1227      *
1228      * @param block_move_target $target with the necessary details.
1229      * @return string the HTML to be output.
1230      */
1231     public function block_move_target($target) {
1232         return html_writer::tag('a', html_writer::tag('span', $target->text, array('class' => 'accesshide')), array('href' => $target->url, 'class' => 'blockmovetarget'));
1233     }
1235     /**
1236      * Renders a special html link with attached action
1237      *
1238      * @param string|moodle_url $url
1239      * @param string $text HTML fragment
1240      * @param component_action $action
1241      * @param array $attributes associative array of html link attributes + disabled
1242      * @return string HTML fragment
1243      */
1244     public function action_link($url, $text, component_action $action = null, array $attributes=null) {
1245         if (!($url instanceof moodle_url)) {
1246             $url = new moodle_url($url);
1247         }
1248         $link = new action_link($url, $text, $action, $attributes);
1250         return $this->render($link);
1251     }
1253     /**
1254      * Renders an action_link object.
1255      *
1256      * The provided link is renderer and the HTML returned. At the same time the
1257      * associated actions are setup in JS by {@link core_renderer::add_action_handler()}
1258      *
1259      * @param action_link $link
1260      * @return string HTML fragment
1261      */
1262     protected function render_action_link(action_link $link) {
1263         global $CFG;
1265         if ($link->text instanceof renderable) {
1266             $text = $this->render($link->text);
1267         } else {
1268             $text = $link->text;
1269         }
1271         // A disabled link is rendered as formatted text
1272         if (!empty($link->attributes['disabled'])) {
1273             // do not use div here due to nesting restriction in xhtml strict
1274             return html_writer::tag('span', $text, array('class'=>'currentlink'));
1275         }
1277         $attributes = $link->attributes;
1278         unset($link->attributes['disabled']);
1279         $attributes['href'] = $link->url;
1281         if ($link->actions) {
1282             if (empty($attributes['id'])) {
1283                 $id = html_writer::random_id('action_link');
1284                 $attributes['id'] = $id;
1285             } else {
1286                 $id = $attributes['id'];
1287             }
1288             foreach ($link->actions as $action) {
1289                 $this->add_action_handler($action, $id);
1290             }
1291         }
1293         return html_writer::tag('a', $text, $attributes);
1294     }
1297     /**
1298      * Renders an action_icon.
1299      *
1300      * This function uses the {@link core_renderer::action_link()} method for the
1301      * most part. What it does different is prepare the icon as HTML and use it
1302      * as the link text.
1303      *
1304      * @param string|moodle_url $url A string URL or moodel_url
1305      * @param pix_icon $pixicon
1306      * @param component_action $action
1307      * @param array $attributes associative array of html link attributes + disabled
1308      * @param bool $linktext show title next to image in link
1309      * @return string HTML fragment
1310      */
1311     public function action_icon($url, pix_icon $pixicon, component_action $action = null, array $attributes = null, $linktext=false) {
1312         if (!($url instanceof moodle_url)) {
1313             $url = new moodle_url($url);
1314         }
1315         $attributes = (array)$attributes;
1317         if (empty($attributes['class'])) {
1318             // let ppl override the class via $options
1319             $attributes['class'] = 'action-icon';
1320         }
1322         $icon = $this->render($pixicon);
1324         if ($linktext) {
1325             $text = $pixicon->attributes['alt'];
1326         } else {
1327             $text = '';
1328         }
1330         return $this->action_link($url, $text.$icon, $action, $attributes);
1331     }
1333    /**
1334     * Print a message along with button choices for Continue/Cancel
1335     *
1336     * If a string or moodle_url is given instead of a single_button, method defaults to post.
1337     *
1338     * @param string $message The question to ask the user
1339     * @param single_button|moodle_url|string $continue The single_button component representing the Continue answer. Can also be a moodle_url or string URL
1340     * @param single_button|moodle_url|string $cancel The single_button component representing the Cancel answer. Can also be a moodle_url or string URL
1341     * @return string HTML fragment
1342     */
1343     public function confirm($message, $continue, $cancel) {
1344         if ($continue instanceof single_button) {
1345             // ok
1346         } else if (is_string($continue)) {
1347             $continue = new single_button(new moodle_url($continue), get_string('continue'), 'post');
1348         } else if ($continue instanceof moodle_url) {
1349             $continue = new single_button($continue, get_string('continue'), 'post');
1350         } else {
1351             throw new coding_exception('The continue param to $OUTPUT->confirm() must be either a URL (string/moodle_url) or a single_button instance.');
1352         }
1354         if ($cancel instanceof single_button) {
1355             // ok
1356         } else if (is_string($cancel)) {
1357             $cancel = new single_button(new moodle_url($cancel), get_string('cancel'), 'get');
1358         } else if ($cancel instanceof moodle_url) {
1359             $cancel = new single_button($cancel, get_string('cancel'), 'get');
1360         } else {
1361             throw new coding_exception('The cancel param to $OUTPUT->confirm() must be either a URL (string/moodle_url) or a single_button instance.');
1362         }
1364         $output = $this->box_start('generalbox', 'notice');
1365         $output .= html_writer::tag('p', $message);
1366         $output .= html_writer::tag('div', $this->render($continue) . $this->render($cancel), array('class' => 'buttons'));
1367         $output .= $this->box_end();
1368         return $output;
1369     }
1371     /**
1372      * Returns a form with a single button.
1373      *
1374      * @param string|moodle_url $url
1375      * @param string $label button text
1376      * @param string $method get or post submit method
1377      * @param array $options associative array {disabled, title, etc.}
1378      * @return string HTML fragment
1379      */
1380     public function single_button($url, $label, $method='post', array $options=null) {
1381         if (!($url instanceof moodle_url)) {
1382             $url = new moodle_url($url);
1383         }
1384         $button = new single_button($url, $label, $method);
1386         foreach ((array)$options as $key=>$value) {
1387             if (array_key_exists($key, $button)) {
1388                 $button->$key = $value;
1389             }
1390         }
1392         return $this->render($button);
1393     }
1395     /**
1396      * Renders a single button widget.
1397      *
1398      * This will return HTML to display a form containing a single button.
1399      *
1400      * @param single_button $button
1401      * @return string HTML fragment
1402      */
1403     protected function render_single_button(single_button $button) {
1404         $attributes = array('type'     => 'submit',
1405                             'value'    => $button->label,
1406                             'disabled' => $button->disabled ? 'disabled' : null,
1407                             'title'    => $button->tooltip);
1409         if ($button->actions) {
1410             $id = html_writer::random_id('single_button');
1411             $attributes['id'] = $id;
1412             foreach ($button->actions as $action) {
1413                 $this->add_action_handler($action, $id);
1414             }
1415         }
1417         // first the input element
1418         $output = html_writer::empty_tag('input', $attributes);
1420         // then hidden fields
1421         $params = $button->url->params();
1422         if ($button->method === 'post') {
1423             $params['sesskey'] = sesskey();
1424         }
1425         foreach ($params as $var => $val) {
1426             $output .= html_writer::empty_tag('input', array('type' => 'hidden', 'name' => $var, 'value' => $val));
1427         }
1429         // then div wrapper for xhtml strictness
1430         $output = html_writer::tag('div', $output);
1432         // now the form itself around it
1433         if ($button->method === 'get') {
1434             $url = $button->url->out_omit_querystring(true); // url without params, the anchor part allowed
1435         } else {
1436             $url = $button->url->out_omit_querystring();     // url without params, the anchor part not allowed
1437         }
1438         if ($url === '') {
1439             $url = '#'; // there has to be always some action
1440         }
1441         $attributes = array('method' => $button->method,
1442                             'action' => $url,
1443                             'id'     => $button->formid);
1444         $output = html_writer::tag('form', $output, $attributes);
1446         // and finally one more wrapper with class
1447         return html_writer::tag('div', $output, array('class' => $button->class));
1448     }
1450     /**
1451      * Returns a form with a single select widget.
1452      *
1453      * @param moodle_url $url form action target, includes hidden fields
1454      * @param string $name name of selection field - the changing parameter in url
1455      * @param array $options list of options
1456      * @param string $selected selected element
1457      * @param array $nothing
1458      * @param string $formid
1459      * @return string HTML fragment
1460      */
1461     public function single_select($url, $name, array $options, $selected = '', $nothing = array('' => 'choosedots'), $formid = null) {
1462         if (!($url instanceof moodle_url)) {
1463             $url = new moodle_url($url);
1464         }
1465         $select = new single_select($url, $name, $options, $selected, $nothing, $formid);
1467         return $this->render($select);
1468     }
1470     /**
1471      * Internal implementation of single_select rendering
1472      *
1473      * @param single_select $select
1474      * @return string HTML fragment
1475      */
1476     protected function render_single_select(single_select $select) {
1477         $select = clone($select);
1478         if (empty($select->formid)) {
1479             $select->formid = html_writer::random_id('single_select_f');
1480         }
1482         $output = '';
1483         $params = $select->url->params();
1484         if ($select->method === 'post') {
1485             $params['sesskey'] = sesskey();
1486         }
1487         foreach ($params as $name=>$value) {
1488             $output .= html_writer::empty_tag('input', array('type'=>'hidden', 'name'=>$name, 'value'=>$value));
1489         }
1491         if (empty($select->attributes['id'])) {
1492             $select->attributes['id'] = html_writer::random_id('single_select');
1493         }
1495         if ($select->disabled) {
1496             $select->attributes['disabled'] = 'disabled';
1497         }
1499         if ($select->tooltip) {
1500             $select->attributes['title'] = $select->tooltip;
1501         }
1503         $select->attributes['class'] = 'autosubmit';
1504         if ($select->class) {
1505             $select->attributes['class'] .= ' ' . $select->class;
1506         }
1508         if ($select->label) {
1509             $output .= html_writer::label($select->label, $select->attributes['id'], false, $select->labelattributes);
1510         }
1512         if ($select->helpicon instanceof help_icon) {
1513             $output .= $this->render($select->helpicon);
1514         } else if ($select->helpicon instanceof old_help_icon) {
1515             $output .= $this->render($select->helpicon);
1516         }
1517         $output .= html_writer::select($select->options, $select->name, $select->selected, $select->nothing, $select->attributes);
1519         $go = html_writer::empty_tag('input', array('type'=>'submit', 'value'=>get_string('go')));
1520         $output .= html_writer::tag('noscript', html_writer::tag('div', $go), array('class' => 'inline'));
1522         $nothing = empty($select->nothing) ? false : key($select->nothing);
1523         $this->page->requires->yui_module('moodle-core-formautosubmit',
1524             'M.core.init_formautosubmit',
1525             array(array('selectid' => $select->attributes['id'], 'nothing' => $nothing))
1526         );
1528         // then div wrapper for xhtml strictness
1529         $output = html_writer::tag('div', $output);
1531         // now the form itself around it
1532         if ($select->method === 'get') {
1533             $url = $select->url->out_omit_querystring(true); // url without params, the anchor part allowed
1534         } else {
1535             $url = $select->url->out_omit_querystring();     // url without params, the anchor part not allowed
1536         }
1537         $formattributes = array('method' => $select->method,
1538                                 'action' => $url,
1539                                 'id'     => $select->formid);
1540         $output = html_writer::tag('form', $output, $formattributes);
1542         // and finally one more wrapper with class
1543         return html_writer::tag('div', $output, array('class' => $select->class));
1544     }
1546     /**
1547      * Returns a form with a url select widget.
1548      *
1549      * @param array $urls list of urls - array('/course/view.php?id=1'=>'Frontpage', ....)
1550      * @param string $selected selected element
1551      * @param array $nothing
1552      * @param string $formid
1553      * @return string HTML fragment
1554      */
1555     public function url_select(array $urls, $selected, $nothing = array('' => 'choosedots'), $formid = null) {
1556         $select = new url_select($urls, $selected, $nothing, $formid);
1557         return $this->render($select);
1558     }
1560     /**
1561      * Internal implementation of url_select rendering
1562      *
1563      * @param url_select $select
1564      * @return string HTML fragment
1565      */
1566     protected function render_url_select(url_select $select) {
1567         global $CFG;
1569         $select = clone($select);
1570         if (empty($select->formid)) {
1571             $select->formid = html_writer::random_id('url_select_f');
1572         }
1574         if (empty($select->attributes['id'])) {
1575             $select->attributes['id'] = html_writer::random_id('url_select');
1576         }
1578         if ($select->disabled) {
1579             $select->attributes['disabled'] = 'disabled';
1580         }
1582         if ($select->tooltip) {
1583             $select->attributes['title'] = $select->tooltip;
1584         }
1586         $output = '';
1588         if ($select->label) {
1589             $output .= html_writer::label($select->label, $select->attributes['id'], false, $select->labelattributes);
1590         }
1592         $classes = array();
1593         if (!$select->showbutton) {
1594             $classes[] = 'autosubmit';
1595         }
1596         if ($select->class) {
1597             $classes[] = $select->class;
1598         }
1599         if (count($classes)) {
1600             $select->attributes['class'] = implode(' ', $classes);
1601         }
1603         if ($select->helpicon instanceof help_icon) {
1604             $output .= $this->render($select->helpicon);
1605         } else if ($select->helpicon instanceof old_help_icon) {
1606             $output .= $this->render($select->helpicon);
1607         }
1609         // For security reasons, the script course/jumpto.php requires URL starting with '/'. To keep
1610         // backward compatibility, we are removing heading $CFG->wwwroot from URLs here.
1611         $urls = array();
1612         foreach ($select->urls as $k=>$v) {
1613             if (is_array($v)) {
1614                 // optgroup structure
1615                 foreach ($v as $optgrouptitle => $optgroupoptions) {
1616                     foreach ($optgroupoptions as $optionurl => $optiontitle) {
1617                         if (empty($optionurl)) {
1618                             $safeoptionurl = '';
1619                         } else if (strpos($optionurl, $CFG->wwwroot.'/') === 0) {
1620                             // debugging('URLs passed to url_select should be in local relative form - please fix the code.', DEBUG_DEVELOPER);
1621                             $safeoptionurl = str_replace($CFG->wwwroot, '', $optionurl);
1622                         } else if (strpos($optionurl, '/') !== 0) {
1623                             debugging("Invalid url_select urls parameter inside optgroup: url '$optionurl' is not local relative url!");
1624                             continue;
1625                         } else {
1626                             $safeoptionurl = $optionurl;
1627                         }
1628                         $urls[$k][$optgrouptitle][$safeoptionurl] = $optiontitle;
1629                     }
1630                 }
1631             } else {
1632                 // plain list structure
1633                 if (empty($k)) {
1634                     // nothing selected option
1635                 } else if (strpos($k, $CFG->wwwroot.'/') === 0) {
1636                     $k = str_replace($CFG->wwwroot, '', $k);
1637                 } else if (strpos($k, '/') !== 0) {
1638                     debugging("Invalid url_select urls parameter: url '$k' is not local relative url!");
1639                     continue;
1640                 }
1641                 $urls[$k] = $v;
1642             }
1643         }
1644         $selected = $select->selected;
1645         if (!empty($selected)) {
1646             if (strpos($select->selected, $CFG->wwwroot.'/') === 0) {
1647                 $selected = str_replace($CFG->wwwroot, '', $selected);
1648             } else if (strpos($selected, '/') !== 0) {
1649                 debugging("Invalid value of parameter 'selected': url '$selected' is not local relative url!");
1650             }
1651         }
1653         $output .= html_writer::empty_tag('input', array('type'=>'hidden', 'name'=>'sesskey', 'value'=>sesskey()));
1654         $output .= html_writer::select($urls, 'jump', $selected, $select->nothing, $select->attributes);
1656         if (!$select->showbutton) {
1657             $go = html_writer::empty_tag('input', array('type'=>'submit', 'value'=>get_string('go')));
1658             $output .= html_writer::tag('noscript', html_writer::tag('div', $go), array('class' => 'inline'));
1659             $nothing = empty($select->nothing) ? false : key($select->nothing);
1660             $this->page->requires->yui_module('moodle-core-formautosubmit',
1661                 'M.core.init_formautosubmit',
1662                 array(array('selectid' => $select->attributes['id'], 'nothing' => $nothing))
1663             );
1664         } else {
1665             $output .= html_writer::empty_tag('input', array('type'=>'submit', 'value'=>$select->showbutton));
1666         }
1668         // then div wrapper for xhtml strictness
1669         $output = html_writer::tag('div', $output);
1671         // now the form itself around it
1672         $formattributes = array('method' => 'post',
1673                                 'action' => new moodle_url('/course/jumpto.php'),
1674                                 'id'     => $select->formid);
1675         $output = html_writer::tag('form', $output, $formattributes);
1677         // and finally one more wrapper with class
1678         return html_writer::tag('div', $output, array('class' => $select->class));
1679     }
1681     /**
1682      * Returns a string containing a link to the user documentation.
1683      * Also contains an icon by default. Shown to teachers and admin only.
1684      *
1685      * @param string $path The page link after doc root and language, no leading slash.
1686      * @param string $text The text to be displayed for the link
1687      * @param boolean $forcepopup Whether to force a popup regardless of the value of $CFG->doctonewwindow
1688      * @return string
1689      */
1690     public function doc_link($path, $text = '', $forcepopup = false) {
1691         global $CFG;
1693         $icon = $this->pix_icon('docs', $text, 'moodle', array('class'=>'iconhelp icon-pre'));
1695         $url = new moodle_url(get_docs_url($path));
1697         $attributes = array('href'=>$url);
1698         if (!empty($CFG->doctonewwindow) || $forcepopup) {
1699             $attributes['class'] = 'helplinkpopup';
1700         }
1702         return html_writer::tag('a', $icon.$text, $attributes);
1703     }
1705     /**
1706      * Return HTML for a pix_icon.
1707      *
1708      * @param string $pix short pix name
1709      * @param string $alt mandatory alt attribute
1710      * @param string $component standard compoennt name like 'moodle', 'mod_forum', etc.
1711      * @param array $attributes htm lattributes
1712      * @return string HTML fragment
1713      */
1714     public function pix_icon($pix, $alt, $component='moodle', array $attributes = null) {
1715         $icon = new pix_icon($pix, $alt, $component, $attributes);
1716         return $this->render($icon);
1717     }
1719     /**
1720      * Renders a pix_icon widget and returns the HTML to display it.
1721      *
1722      * @param pix_icon $icon
1723      * @return string HTML fragment
1724      */
1725     protected function render_pix_icon(pix_icon $icon) {
1726         $attributes = $icon->attributes;
1727         $attributes['src'] = $this->pix_url($icon->pix, $icon->component);
1728         return html_writer::empty_tag('img', $attributes);
1729     }
1731     /**
1732      * Return HTML to display an emoticon icon.
1733      *
1734      * @param pix_emoticon $emoticon
1735      * @return string HTML fragment
1736      */
1737     protected function render_pix_emoticon(pix_emoticon $emoticon) {
1738         $attributes = $emoticon->attributes;
1739         $attributes['src'] = $this->pix_url($emoticon->pix, $emoticon->component);
1740         return html_writer::empty_tag('img', $attributes);
1741     }
1743     /**
1744      * Produces the html that represents this rating in the UI
1745      *
1746      * @param rating $rating the page object on which this rating will appear
1747      * @return string
1748      */
1749     function render_rating(rating $rating) {
1750         global $CFG, $USER;
1752         if ($rating->settings->aggregationmethod == RATING_AGGREGATE_NONE) {
1753             return null;//ratings are turned off
1754         }
1756         $ratingmanager = new rating_manager();
1757         // Initialise the JavaScript so ratings can be done by AJAX.
1758         $ratingmanager->initialise_rating_javascript($this->page);
1760         $strrate = get_string("rate", "rating");
1761         $ratinghtml = ''; //the string we'll return
1763         // permissions check - can they view the aggregate?
1764         if ($rating->user_can_view_aggregate()) {
1766             $aggregatelabel = $ratingmanager->get_aggregate_label($rating->settings->aggregationmethod);
1767             $aggregatestr   = $rating->get_aggregate_string();
1769             $aggregatehtml  = html_writer::tag('span', $aggregatestr, array('id' => 'ratingaggregate'.$rating->itemid, 'class' => 'ratingaggregate')).' ';
1770             if ($rating->count > 0) {
1771                 $countstr = "({$rating->count})";
1772             } else {
1773                 $countstr = '-';
1774             }
1775             $aggregatehtml .= html_writer::tag('span', $countstr, array('id'=>"ratingcount{$rating->itemid}", 'class' => 'ratingcount')).' ';
1777             $ratinghtml .= html_writer::tag('span', $aggregatelabel, array('class'=>'rating-aggregate-label'));
1778             if ($rating->settings->permissions->viewall && $rating->settings->pluginpermissions->viewall) {
1780                 $nonpopuplink = $rating->get_view_ratings_url();
1781                 $popuplink = $rating->get_view_ratings_url(true);
1783                 $action = new popup_action('click', $popuplink, 'ratings', array('height' => 400, 'width' => 600));
1784                 $ratinghtml .= $this->action_link($nonpopuplink, $aggregatehtml, $action);
1785             } else {
1786                 $ratinghtml .= $aggregatehtml;
1787             }
1788         }
1790         $formstart = null;
1791         // if the item doesn't belong to the current user, the user has permission to rate
1792         // and we're within the assessable period
1793         if ($rating->user_can_rate()) {
1795             $rateurl = $rating->get_rate_url();
1796             $inputs = $rateurl->params();
1798             //start the rating form
1799             $formattrs = array(
1800                 'id'     => "postrating{$rating->itemid}",
1801                 'class'  => 'postratingform',
1802                 'method' => 'post',
1803                 'action' => $rateurl->out_omit_querystring()
1804             );
1805             $formstart  = html_writer::start_tag('form', $formattrs);
1806             $formstart .= html_writer::start_tag('div', array('class' => 'ratingform'));
1808             // add the hidden inputs
1809             foreach ($inputs as $name => $value) {
1810                 $attributes = array('type' => 'hidden', 'class' => 'ratinginput', 'name' => $name, 'value' => $value);
1811                 $formstart .= html_writer::empty_tag('input', $attributes);
1812             }
1814             if (empty($ratinghtml)) {
1815                 $ratinghtml .= $strrate.': ';
1816             }
1817             $ratinghtml = $formstart.$ratinghtml;
1819             $scalearray = array(RATING_UNSET_RATING => $strrate.'...') + $rating->settings->scale->scaleitems;
1820             $scaleattrs = array('class'=>'postratingmenu ratinginput','id'=>'menurating'.$rating->itemid);
1821             $ratinghtml .= html_writer::label($rating->rating, 'menurating'.$rating->itemid, false, array('class' => 'accesshide'));
1822             $ratinghtml .= html_writer::select($scalearray, 'rating', $rating->rating, false, $scaleattrs);
1824             //output submit button
1825             $ratinghtml .= html_writer::start_tag('span', array('class'=>"ratingsubmit"));
1827             $attributes = array('type' => 'submit', 'class' => 'postratingmenusubmit', 'id' => 'postratingsubmit'.$rating->itemid, 'value' => s(get_string('rate', 'rating')));
1828             $ratinghtml .= html_writer::empty_tag('input', $attributes);
1830             if (!$rating->settings->scale->isnumeric) {
1831                 // If a global scale, try to find current course ID from the context
1832                 if (empty($rating->settings->scale->courseid) and $coursecontext = $rating->context->get_course_context(false)) {
1833                     $courseid = $coursecontext->instanceid;
1834                 } else {
1835                     $courseid = $rating->settings->scale->courseid;
1836                 }
1837                 $ratinghtml .= $this->help_icon_scale($courseid, $rating->settings->scale);
1838             }
1839             $ratinghtml .= html_writer::end_tag('span');
1840             $ratinghtml .= html_writer::end_tag('div');
1841             $ratinghtml .= html_writer::end_tag('form');
1842         }
1844         return $ratinghtml;
1845     }
1847     /**
1848      * Centered heading with attached help button (same title text)
1849      * and optional icon attached.
1850      *
1851      * @param string $text A heading text
1852      * @param string $helpidentifier The keyword that defines a help page
1853      * @param string $component component name
1854      * @param string|moodle_url $icon
1855      * @param string $iconalt icon alt text
1856      * @return string HTML fragment
1857      */
1858     public function heading_with_help($text, $helpidentifier, $component = 'moodle', $icon = '', $iconalt = '') {
1859         $image = '';
1860         if ($icon) {
1861             $image = $this->pix_icon($icon, $iconalt, $component, array('class'=>'icon'));
1862         }
1864         $help = '';
1865         if ($helpidentifier) {
1866             $help = $this->help_icon($helpidentifier, $component);
1867         }
1869         return $this->heading($image.$text.$help, 2, 'main help');
1870     }
1872     /**
1873      * Returns HTML to display a help icon.
1874      *
1875      * @deprecated since Moodle 2.0
1876      * @param string $helpidentifier The keyword that defines a help page
1877      * @param string $title A descriptive text for accessibility only
1878      * @param string $component component name
1879      * @param string|bool $linktext true means use $title as link text, string means link text value
1880      * @return string HTML fragment
1881      */
1882     public function old_help_icon($helpidentifier, $title, $component = 'moodle', $linktext = '') {
1883         debugging('The method old_help_icon() is deprecated, please fix the code and use help_icon() method instead', DEBUG_DEVELOPER);
1884         $icon = new old_help_icon($helpidentifier, $title, $component);
1885         if ($linktext === true) {
1886             $icon->linktext = $title;
1887         } else if (!empty($linktext)) {
1888             $icon->linktext = $linktext;
1889         }
1890         return $this->render($icon);
1891     }
1893     /**
1894      * Implementation of user image rendering.
1895      *
1896      * @param old_help_icon $helpicon A help icon instance
1897      * @return string HTML fragment
1898      */
1899     protected function render_old_help_icon(old_help_icon $helpicon) {
1900         global $CFG;
1902         // first get the help image icon
1903         $src = $this->pix_url('help');
1905         if (empty($helpicon->linktext)) {
1906             $alt = $helpicon->title;
1907         } else {
1908             $alt = get_string('helpwiththis');
1909         }
1911         $attributes = array('src'=>$src, 'alt'=>$alt, 'class'=>'iconhelp');
1912         $output = html_writer::empty_tag('img', $attributes);
1914         // add the link text if given
1915         if (!empty($helpicon->linktext)) {
1916             // the spacing has to be done through CSS
1917             $output .= $helpicon->linktext;
1918         }
1920         // now create the link around it - we need https on loginhttps pages
1921         $url = new moodle_url($CFG->httpswwwroot.'/help.php', array('component' => $helpicon->component, 'identifier' => $helpicon->helpidentifier, 'lang'=>current_language()));
1923         // note: this title is displayed only if JS is disabled, otherwise the link will have the new ajax tooltip
1924         $title = get_string('helpprefix2', '', trim($helpicon->title, ". \t"));
1926         $attributes = array('href'=>$url, 'title'=>$title, 'aria-haspopup' => 'true');
1927         $id = html_writer::random_id('helpicon');
1928         $attributes['id'] = $id;
1929         $output = html_writer::tag('a', $output, $attributes);
1931         $this->page->requires->js_init_call('M.util.help_icon.add', array(array('id'=>$id, 'url'=>$url->out(false))));
1932         $this->page->requires->string_for_js('close', 'form');
1934         // and finally span
1935         return html_writer::tag('span', $output, array('class' => 'helplink'));
1936     }
1938     /**
1939      * Returns HTML to display a help icon.
1940      *
1941      * @param string $identifier The keyword that defines a help page
1942      * @param string $component component name
1943      * @param string|bool $linktext true means use $title as link text, string means link text value
1944      * @return string HTML fragment
1945      */
1946     public function help_icon($identifier, $component = 'moodle', $linktext = '') {
1947         $icon = new help_icon($identifier, $component);
1948         $icon->diag_strings();
1949         if ($linktext === true) {
1950             $icon->linktext = get_string($icon->identifier, $icon->component);
1951         } else if (!empty($linktext)) {
1952             $icon->linktext = $linktext;
1953         }
1954         return $this->render($icon);
1955     }
1957     /**
1958      * Implementation of user image rendering.
1959      *
1960      * @param help_icon $helpicon A help icon instance
1961      * @return string HTML fragment
1962      */
1963     protected function render_help_icon(help_icon $helpicon) {
1964         global $CFG;
1966         // first get the help image icon
1967         $src = $this->pix_url('help');
1969         $title = get_string($helpicon->identifier, $helpicon->component);
1971         if (empty($helpicon->linktext)) {
1972             $alt = get_string('helpprefix2', '', trim($title, ". \t"));
1973         } else {
1974             $alt = get_string('helpwiththis');
1975         }
1977         $attributes = array('src'=>$src, 'alt'=>$alt, 'class'=>'iconhelp');
1978         $output = html_writer::empty_tag('img', $attributes);
1980         // add the link text if given
1981         if (!empty($helpicon->linktext)) {
1982             // the spacing has to be done through CSS
1983             $output .= $helpicon->linktext;
1984         }
1986         // now create the link around it - we need https on loginhttps pages
1987         $url = new moodle_url($CFG->httpswwwroot.'/help.php', array('component' => $helpicon->component, 'identifier' => $helpicon->identifier, 'lang'=>current_language()));
1989         // note: this title is displayed only if JS is disabled, otherwise the link will have the new ajax tooltip
1990         $title = get_string('helpprefix2', '', trim($title, ". \t"));
1992         $attributes = array('href'=>$url, 'title'=>$title, 'aria-haspopup' => 'true', 'class' => 'tooltip');
1993         $output = html_writer::tag('a', $output, $attributes);
1995         $this->page->requires->js_init_call('M.util.help_icon.setup');
1996         $this->page->requires->string_for_js('close', 'form');
1998         // and finally span
1999         return html_writer::tag('span', $output, array('class' => 'helplink'));
2000     }
2002     /**
2003      * Returns HTML to display a scale help icon.
2004      *
2005      * @param int $courseid
2006      * @param stdClass $scale instance
2007      * @return string HTML fragment
2008      */
2009     public function help_icon_scale($courseid, stdClass $scale) {
2010         global $CFG;
2012         $title = get_string('helpprefix2', '', $scale->name) .' ('.get_string('newwindow').')';
2014         $icon = $this->pix_icon('help', get_string('scales'), 'moodle', array('class'=>'iconhelp'));
2016         $scaleid = abs($scale->id);
2018         $link = new moodle_url('/course/scales.php', array('id' => $courseid, 'list' => true, 'scaleid' => $scaleid));
2019         $action = new popup_action('click', $link, 'ratingscale');
2021         return html_writer::tag('span', $this->action_link($link, $icon, $action), array('class' => 'helplink'));
2022     }
2024     /**
2025      * Creates and returns a spacer image with optional line break.
2026      *
2027      * @param array $attributes Any HTML attributes to add to the spaced.
2028      * @param bool $br Include a BR after the spacer.... DON'T USE THIS. Don't be
2029      *     laxy do it with CSS which is a much better solution.
2030      * @return string HTML fragment
2031      */
2032     public function spacer(array $attributes = null, $br = false) {
2033         $attributes = (array)$attributes;
2034         if (empty($attributes['width'])) {
2035             $attributes['width'] = 1;
2036         }
2037         if (empty($attributes['height'])) {
2038             $attributes['height'] = 1;
2039         }
2040         $attributes['class'] = 'spacer';
2042         $output = $this->pix_icon('spacer', '', 'moodle', $attributes);
2044         if (!empty($br)) {
2045             $output .= '<br />';
2046         }
2048         return $output;
2049     }
2051     /**
2052      * Returns HTML to display the specified user's avatar.
2053      *
2054      * User avatar may be obtained in two ways:
2055      * <pre>
2056      * // Option 1: (shortcut for simple cases, preferred way)
2057      * // $user has come from the DB and has fields id, picture, imagealt, firstname and lastname
2058      * $OUTPUT->user_picture($user, array('popup'=>true));
2059      *
2060      * // Option 2:
2061      * $userpic = new user_picture($user);
2062      * // Set properties of $userpic
2063      * $userpic->popup = true;
2064      * $OUTPUT->render($userpic);
2065      * </pre>
2066      *
2067      * @param stdClass $user Object with at least fields id, picture, imagealt, firstname, lastname
2068      *     If any of these are missing, the database is queried. Avoid this
2069      *     if at all possible, particularly for reports. It is very bad for performance.
2070      * @param array $options associative array with user picture options, used only if not a user_picture object,
2071      *     options are:
2072      *     - courseid=$this->page->course->id (course id of user profile in link)
2073      *     - size=35 (size of image)
2074      *     - link=true (make image clickable - the link leads to user profile)
2075      *     - popup=false (open in popup)
2076      *     - alttext=true (add image alt attribute)
2077      *     - class = image class attribute (default 'userpicture')
2078      * @return string HTML fragment
2079      */
2080     public function user_picture(stdClass $user, array $options = null) {
2081         $userpicture = new user_picture($user);
2082         foreach ((array)$options as $key=>$value) {
2083             if (array_key_exists($key, $userpicture)) {
2084                 $userpicture->$key = $value;
2085             }
2086         }
2087         return $this->render($userpicture);
2088     }
2090     /**
2091      * Internal implementation of user image rendering.
2092      *
2093      * @param user_picture $userpicture
2094      * @return string
2095      */
2096     protected function render_user_picture(user_picture $userpicture) {
2097         global $CFG, $DB;
2099         $user = $userpicture->user;
2101         if ($userpicture->alttext) {
2102             if (!empty($user->imagealt)) {
2103                 $alt = $user->imagealt;
2104             } else {
2105                 $alt = get_string('pictureof', '', fullname($user));
2106             }
2107         } else {
2108             $alt = '';
2109         }
2111         if (empty($userpicture->size)) {
2112             $size = 35;
2113         } else if ($userpicture->size === true or $userpicture->size == 1) {
2114             $size = 100;
2115         } else {
2116             $size = $userpicture->size;
2117         }
2119         $class = $userpicture->class;
2121         if ($user->picture == 0) {
2122             $class .= ' defaultuserpic';
2123         }
2125         $src = $userpicture->get_url($this->page, $this);
2127         $attributes = array('src'=>$src, 'alt'=>$alt, 'title'=>$alt, 'class'=>$class, 'width'=>$size, 'height'=>$size);
2129         // get the image html output fisrt
2130         $output = html_writer::empty_tag('img', $attributes);
2132         // then wrap it in link if needed
2133         if (!$userpicture->link) {
2134             return $output;
2135         }
2137         if (empty($userpicture->courseid)) {
2138             $courseid = $this->page->course->id;
2139         } else {
2140             $courseid = $userpicture->courseid;
2141         }
2143         if ($courseid == SITEID) {
2144             $url = new moodle_url('/user/profile.php', array('id' => $user->id));
2145         } else {
2146             $url = new moodle_url('/user/view.php', array('id' => $user->id, 'course' => $courseid));
2147         }
2149         $attributes = array('href'=>$url);
2151         if ($userpicture->popup) {
2152             $id = html_writer::random_id('userpicture');
2153             $attributes['id'] = $id;
2154             $this->add_action_handler(new popup_action('click', $url), $id);
2155         }
2157         return html_writer::tag('a', $output, $attributes);
2158     }
2160     /**
2161      * Internal implementation of file tree viewer items rendering.
2162      *
2163      * @param array $dir
2164      * @return string
2165      */
2166     public function htmllize_file_tree($dir) {
2167         if (empty($dir['subdirs']) and empty($dir['files'])) {
2168             return '';
2169         }
2170         $result = '<ul>';
2171         foreach ($dir['subdirs'] as $subdir) {
2172             $result .= '<li>'.s($subdir['dirname']).' '.$this->htmllize_file_tree($subdir).'</li>';
2173         }
2174         foreach ($dir['files'] as $file) {
2175             $filename = $file->get_filename();
2176             $result .= '<li><span>'.html_writer::link($file->fileurl, $filename).'</span></li>';
2177         }
2178         $result .= '</ul>';
2180         return $result;
2181     }
2183     /**
2184      * Returns HTML to display the file picker
2185      *
2186      * <pre>
2187      * $OUTPUT->file_picker($options);
2188      * </pre>
2189      *
2190      * @param array $options associative array with file manager options
2191      *   options are:
2192      *       maxbytes=>-1,
2193      *       itemid=>0,
2194      *       client_id=>uniqid(),
2195      *       acepted_types=>'*',
2196      *       return_types=>FILE_INTERNAL,
2197      *       context=>$PAGE->context
2198      * @return string HTML fragment
2199      */
2200     public function file_picker($options) {
2201         $fp = new file_picker($options);
2202         return $this->render($fp);
2203     }
2205     /**
2206      * Internal implementation of file picker rendering.
2207      *
2208      * @param file_picker $fp
2209      * @return string
2210      */
2211     public function render_file_picker(file_picker $fp) {
2212         global $CFG, $OUTPUT, $USER;
2213         $options = $fp->options;
2214         $client_id = $options->client_id;
2215         $strsaved = get_string('filesaved', 'repository');
2216         $straddfile = get_string('openpicker', 'repository');
2217         $strloading  = get_string('loading', 'repository');
2218         $strdndenabled = get_string('dndenabled_inbox', 'moodle');
2219         $strdroptoupload = get_string('droptoupload', 'moodle');
2220         $icon_progress = $OUTPUT->pix_icon('i/loading_small', $strloading).'';
2222         $currentfile = $options->currentfile;
2223         if (empty($currentfile)) {
2224             $currentfile = '';
2225         } else {
2226             $currentfile .= ' - ';
2227         }
2228         if ($options->maxbytes) {
2229             $size = $options->maxbytes;
2230         } else {
2231             $size = get_max_upload_file_size();
2232         }
2233         if ($size == -1) {
2234             $maxsize = '';
2235         } else {
2236             $maxsize = get_string('maxfilesize', 'moodle', display_size($size));
2237         }
2238         if ($options->buttonname) {
2239             $buttonname = ' name="' . $options->buttonname . '"';
2240         } else {
2241             $buttonname = '';
2242         }
2243         $html = <<<EOD
2244 <div class="filemanager-loading mdl-align" id='filepicker-loading-{$client_id}'>
2245 $icon_progress
2246 </div>
2247 <div id="filepicker-wrapper-{$client_id}" class="mdl-left" style="display:none">
2248     <div>
2249         <input type="button" class="fp-btn-choose" id="filepicker-button-{$client_id}" value="{$straddfile}"{$buttonname}/>
2250         <span> $maxsize </span>
2251     </div>
2252 EOD;
2253         if ($options->env != 'url') {
2254             $html .= <<<EOD
2255     <div id="file_info_{$client_id}" class="mdl-left filepicker-filelist" style="position: relative">
2256     <div class="filepicker-filename">
2257         <div class="filepicker-container">$currentfile<div class="dndupload-message">$strdndenabled <br/><div class="dndupload-arrow"></div></div></div>
2258         <div class="dndupload-progressbars"></div>
2259     </div>
2260     <div><div class="dndupload-target">{$strdroptoupload}<br/><div class="dndupload-arrow"></div></div></div>
2261     </div>
2262 EOD;
2263         }
2264         $html .= '</div>';
2265         return $html;
2266     }
2268     /**
2269      * Returns HTML to display the 'Update this Modulename' button that appears on module pages.
2270      *
2271      * @param string $cmid the course_module id.
2272      * @param string $modulename the module name, eg. "forum", "quiz" or "workshop"
2273      * @return string the HTML for the button, if this user has permission to edit it, else an empty string.
2274      */
2275     public function update_module_button($cmid, $modulename) {
2276         global $CFG;
2277         if (has_capability('moodle/course:manageactivities', context_module::instance($cmid))) {
2278             $modulename = get_string('modulename', $modulename);
2279             $string = get_string('updatethis', '', $modulename);
2280             $url = new moodle_url("$CFG->wwwroot/course/mod.php", array('update' => $cmid, 'return' => true, 'sesskey' => sesskey()));
2281             return $this->single_button($url, $string);
2282         } else {
2283             return '';
2284         }
2285     }
2287     /**
2288      * Returns HTML to display a "Turn editing on/off" button in a form.
2289      *
2290      * @param moodle_url $url The URL + params to send through when clicking the button
2291      * @return string HTML the button
2292      */
2293     public function edit_button(moodle_url $url) {
2295         $url->param('sesskey', sesskey());
2296         if ($this->page->user_is_editing()) {
2297             $url->param('edit', 'off');
2298             $editstring = get_string('turneditingoff');
2299         } else {
2300             $url->param('edit', 'on');
2301             $editstring = get_string('turneditingon');
2302         }
2304         return $this->single_button($url, $editstring);
2305     }
2307     /**
2308      * Returns HTML to display a simple button to close a window
2309      *
2310      * @param string $text The lang string for the button's label (already output from get_string())
2311      * @return string html fragment
2312      */
2313     public function close_window_button($text='') {
2314         if (empty($text)) {
2315             $text = get_string('closewindow');
2316         }
2317         $button = new single_button(new moodle_url('#'), $text, 'get');
2318         $button->add_action(new component_action('click', 'close_window'));
2320         return $this->container($this->render($button), 'closewindow');
2321     }
2323     /**
2324      * Output an error message. By default wraps the error message in <span class="error">.
2325      * If the error message is blank, nothing is output.
2326      *
2327      * @param string $message the error message.
2328      * @return string the HTML to output.
2329      */
2330     public function error_text($message) {
2331         if (empty($message)) {
2332             return '';
2333         }
2334         $message = $this->pix_icon('i/warning', get_string('error'), '', array('class' => 'icon icon-pre', 'title'=>'')) . $message;
2335         return html_writer::tag('span', $message, array('class' => 'error'));
2336     }
2338     /**
2339      * Do not call this function directly.
2340      *
2341      * To terminate the current script with a fatal error, call the {@link print_error}
2342      * function, or throw an exception. Doing either of those things will then call this
2343      * function to display the error, before terminating the execution.
2344      *
2345      * @param string $message The message to output
2346      * @param string $moreinfourl URL where more info can be found about the error
2347      * @param string $link Link for the Continue button
2348      * @param array $backtrace The execution backtrace
2349      * @param string $debuginfo Debugging information
2350      * @return string the HTML to output.
2351      */
2352     public function fatal_error($message, $moreinfourl, $link, $backtrace, $debuginfo = null) {
2353         global $CFG;
2355         $output = '';
2356         $obbuffer = '';
2358         if ($this->has_started()) {
2359             // we can not always recover properly here, we have problems with output buffering,
2360             // html tables, etc.
2361             $output .= $this->opencontainers->pop_all_but_last();
2363         } else {
2364             // It is really bad if library code throws exception when output buffering is on,
2365             // because the buffered text would be printed before our start of page.
2366             // NOTE: this hack might be behave unexpectedly in case output buffering is enabled in PHP.ini
2367             error_reporting(0); // disable notices from gzip compression, etc.
2368             while (ob_get_level() > 0) {
2369                 $buff = ob_get_clean();
2370                 if ($buff === false) {
2371                     break;
2372                 }
2373                 $obbuffer .= $buff;
2374             }
2375             error_reporting($CFG->debug);
2377             // Header not yet printed
2378             if (isset($_SERVER['SERVER_PROTOCOL'])) {
2379                 // server protocol should be always present, because this render
2380                 // can not be used from command line or when outputting custom XML
2381                 @header($_SERVER['SERVER_PROTOCOL'] . ' 404 Not Found');
2382             }
2383             $this->page->set_context(null); // ugly hack - make sure page context is set to something, we do not want bogus warnings here
2384             $this->page->set_url('/'); // no url
2385             //$this->page->set_pagelayout('base'); //TODO: MDL-20676 blocks on error pages are weird, unfortunately it somehow detect the pagelayout from URL :-(
2386             $this->page->set_title(get_string('error'));
2387             $this->page->set_heading($this->page->course->fullname);
2388             $output .= $this->header();
2389         }
2391         $message = '<p class="errormessage">' . $message . '</p>'.
2392                 '<p class="errorcode"><a href="' . $moreinfourl . '">' .
2393                 get_string('moreinformation') . '</a></p>';
2394         if (empty($CFG->rolesactive)) {
2395             $message .= '<p class="errormessage">' . get_string('installproblem', 'error') . '</p>';
2396             //It is usually not possible to recover from errors triggered during installation, you may need to create a new database or use a different database prefix for new installation.
2397         }
2398         $output .= $this->box($message, 'errorbox');
2400         if (debugging('', DEBUG_DEVELOPER)) {
2401             if (!empty($debuginfo)) {
2402                 $debuginfo = s($debuginfo); // removes all nasty JS
2403                 $debuginfo = str_replace("\n", '<br />', $debuginfo); // keep newlines
2404                 $output .= $this->notification('<strong>Debug info:</strong> '.$debuginfo, 'notifytiny');
2405             }
2406             if (!empty($backtrace)) {
2407                 $output .= $this->notification('<strong>Stack trace:</strong> '.format_backtrace($backtrace), 'notifytiny');
2408             }
2409             if ($obbuffer !== '' ) {
2410                 $output .= $this->notification('<strong>Output buffer:</strong> '.s($obbuffer), 'notifytiny');
2411             }
2412         }
2414         if (empty($CFG->rolesactive)) {
2415             // continue does not make much sense if moodle is not installed yet because error is most probably not recoverable
2416         } else if (!empty($link)) {
2417             $output .= $this->continue_button($link);
2418         }
2420         $output .= $this->footer();
2422         // Padding to encourage IE to display our error page, rather than its own.
2423         $output .= str_repeat(' ', 512);
2425         return $output;
2426     }
2428     /**
2429      * Output a notification (that is, a status message about something that has
2430      * just happened).
2431      *
2432      * @param string $message the message to print out
2433      * @param string $classes normally 'notifyproblem' or 'notifysuccess'.
2434      * @return string the HTML to output.
2435      */
2436     public function notification($message, $classes = 'notifyproblem') {
2437         return html_writer::tag('div', clean_text($message), array('class' => renderer_base::prepare_classes($classes)));
2438     }
2440     /**
2441      * Returns HTML to display a continue button that goes to a particular URL.
2442      *
2443      * @param string|moodle_url $url The url the button goes to.
2444      * @return string the HTML to output.
2445      */
2446     public function continue_button($url) {
2447         if (!($url instanceof moodle_url)) {
2448             $url = new moodle_url($url);
2449         }
2450         $button = new single_button($url, get_string('continue'), 'get');
2451         $button->class = 'continuebutton';
2453         return $this->render($button);
2454     }
2456     /**
2457      * Returns HTML to display a single paging bar to provide access to other pages  (usually in a search)
2458      *
2459      * @param int $totalcount The total number of entries available to be paged through
2460      * @param int $page The page you are currently viewing
2461      * @param int $perpage The number of entries that should be shown per page
2462      * @param string|moodle_url $baseurl url of the current page, the $pagevar parameter is added
2463      * @param string $pagevar name of page parameter that holds the page number
2464      * @return string the HTML to output.
2465      */
2466     public function paging_bar($totalcount, $page, $perpage, $baseurl, $pagevar = 'page') {
2467         $pb = new paging_bar($totalcount, $page, $perpage, $baseurl, $pagevar);
2468         return $this->render($pb);
2469     }
2471     /**
2472      * Internal implementation of paging bar rendering.
2473      *
2474      * @param paging_bar $pagingbar
2475      * @return string
2476      */
2477     protected function render_paging_bar(paging_bar $pagingbar) {
2478         $output = '';
2479         $pagingbar = clone($pagingbar);
2480         $pagingbar->prepare($this, $this->page, $this->target);
2482         if ($pagingbar->totalcount > $pagingbar->perpage) {
2483             $output .= get_string('page') . ':';
2485             if (!empty($pagingbar->previouslink)) {
2486                 $output .= '&#160;(' . $pagingbar->previouslink . ')&#160;';
2487             }
2489             if (!empty($pagingbar->firstlink)) {
2490                 $output .= '&#160;' . $pagingbar->firstlink . '&#160;...';
2491             }
2493             foreach ($pagingbar->pagelinks as $link) {
2494                 $output .= "&#160;&#160;$link";
2495             }
2497             if (!empty($pagingbar->lastlink)) {
2498                 $output .= '&#160;...' . $pagingbar->lastlink . '&#160;';
2499             }
2501             if (!empty($pagingbar->nextlink)) {
2502                 $output .= '&#160;&#160;(' . $pagingbar->nextlink . ')';
2503             }
2504         }
2506         return html_writer::tag('div', $output, array('class' => 'paging'));
2507     }
2509     /**
2510      * Output the place a skip link goes to.
2511      *
2512      * @param string $id The target name from the corresponding $PAGE->requires->skip_link_to($target) call.
2513      * @return string the HTML to output.
2514      */
2515     public function skip_link_target($id = null) {
2516         return html_writer::tag('span', '', array('id' => $id));
2517     }
2519     /**
2520      * Outputs a heading
2521      *
2522      * @param string $text The text of the heading
2523      * @param int $level The level of importance of the heading. Defaulting to 2
2524      * @param string $classes A space-separated list of CSS classes
2525      * @param string $id An optional ID
2526      * @return string the HTML to output.
2527      */
2528     public function heading($text, $level = 2, $classes = 'main', $id = null) {
2529         $level = (integer) $level;
2530         if ($level < 1 or $level > 6) {
2531             throw new coding_exception('Heading level must be an integer between 1 and 6.');
2532         }
2533         return html_writer::tag('h' . $level, $text, array('id' => $id, 'class' => renderer_base::prepare_classes($classes)));
2534     }
2536     /**
2537      * Outputs a box.
2538      *
2539      * @param string $contents The contents of the box
2540      * @param string $classes A space-separated list of CSS classes
2541      * @param string $id An optional ID
2542      * @return string the HTML to output.
2543      */
2544     public function box($contents, $classes = 'generalbox', $id = null) {
2545         return $this->box_start($classes, $id) . $contents . $this->box_end();
2546     }
2548     /**
2549      * Outputs the opening section of a box.
2550      *
2551      * @param string $classes A space-separated list of CSS classes
2552      * @param string $id An optional ID
2553      * @return string the HTML to output.
2554      */
2555     public function box_start($classes = 'generalbox', $id = null) {
2556         $this->opencontainers->push('box', html_writer::end_tag('div'));
2557         return html_writer::start_tag('div', array('id' => $id,
2558                 'class' => 'box ' . renderer_base::prepare_classes($classes)));
2559     }
2561     /**
2562      * Outputs the closing section of a box.
2563      *
2564      * @return string the HTML to output.
2565      */
2566     public function box_end() {
2567         return $this->opencontainers->pop('box');
2568     }
2570     /**
2571      * Outputs a container.
2572      *
2573      * @param string $contents The contents of the box
2574      * @param string $classes A space-separated list of CSS classes
2575      * @param string $id An optional ID
2576      * @return string the HTML to output.
2577      */
2578     public function container($contents, $classes = null, $id = null) {
2579         return $this->container_start($classes, $id) . $contents . $this->container_end();
2580     }
2582     /**
2583      * Outputs the opening section of a container.
2584      *
2585      * @param string $classes A space-separated list of CSS classes
2586      * @param string $id An optional ID
2587      * @return string the HTML to output.
2588      */
2589     public function container_start($classes = null, $id = null) {
2590         $this->opencontainers->push('container', html_writer::end_tag('div'));
2591         return html_writer::start_tag('div', array('id' => $id,
2592                 'class' => renderer_base::prepare_classes($classes)));
2593     }
2595     /**
2596      * Outputs the closing section of a container.
2597      *
2598      * @return string the HTML to output.
2599      */
2600     public function container_end() {
2601         return $this->opencontainers->pop('container');
2602     }
2604     /**
2605      * Make nested HTML lists out of the items
2606      *
2607      * The resulting list will look something like this:
2608      *
2609      * <pre>
2610      * <<ul>>
2611      * <<li>><div class='tree_item parent'>(item contents)</div>
2612      *      <<ul>
2613      *      <<li>><div class='tree_item'>(item contents)</div><</li>>
2614      *      <</ul>>
2615      * <</li>>
2616      * <</ul>>
2617      * </pre>
2618      *
2619      * @param array $items
2620      * @param array $attrs html attributes passed to the top ofs the list
2621      * @return string HTML
2622      */
2623     public function tree_block_contents($items, $attrs = array()) {
2624         // exit if empty, we don't want an empty ul element
2625         if (empty($items)) {
2626             return '';
2627         }
2628         // array of nested li elements
2629         $lis = array();
2630         foreach ($items as $item) {
2631             // this applies to the li item which contains all child lists too
2632             $content = $item->content($this);
2633             $liclasses = array($item->get_css_type());
2634             if (!$item->forceopen || (!$item->forceopen && $item->collapse) || ($item->children->count()==0  && $item->nodetype==navigation_node::NODETYPE_BRANCH)) {
2635                 $liclasses[] = 'collapsed';
2636             }
2637             if ($item->isactive === true) {
2638                 $liclasses[] = 'current_branch';
2639             }
2640             $liattr = array('class'=>join(' ',$liclasses));
2641             // class attribute on the div item which only contains the item content
2642             $divclasses = array('tree_item');
2643             if ($item->children->count()>0  || $item->nodetype==navigation_node::NODETYPE_BRANCH) {
2644                 $divclasses[] = 'branch';
2645             } else {
2646                 $divclasses[] = 'leaf';
2647             }
2648             if (!empty($item->classes) && count($item->classes)>0) {
2649                 $divclasses[] = join(' ', $item->classes);
2650             }
2651             $divattr = array('class'=>join(' ', $divclasses));
2652             if (!empty($item->id)) {
2653                 $divattr['id'] = $item->id;
2654             }
2655             $content = html_writer::tag('p', $content, $divattr) . $this->tree_block_contents($item->children);
2656             if (!empty($item->preceedwithhr) && $item->preceedwithhr===true) {
2657                 $content = html_writer::empty_tag('hr') . $content;
2658             }
2659             $content = html_writer::tag('li', $content, $liattr);
2660             $lis[] = $content;
2661         }
2662         return html_writer::tag('ul', implode("\n", $lis), $attrs);
2663     }
2665     /**
2666      * Return the navbar content so that it can be echoed out by the layout
2667      *
2668      * @return string XHTML navbar
2669      */
2670     public function navbar() {
2671         $items = $this->page->navbar->get_items();
2673         $htmlblocks = array();
2674         // Iterate the navarray and display each node
2675         $itemcount = count($items);
2676         $separator = get_separator();
2677         for ($i=0;$i < $itemcount;$i++) {
2678             $item = $items[$i];
2679             $item->hideicon = true;
2680             if ($i===0) {
2681                 $content = html_writer::tag('li', $this->render($item));
2682             } else {
2683                 $content = html_writer::tag('li', $separator.$this->render($item));
2684             }
2685             $htmlblocks[] = $content;
2686         }
2688         //accessibility: heading for navbar list  (MDL-20446)
2689         $navbarcontent = html_writer::tag('span', get_string('pagepath'), array('class'=>'accesshide'));
2690         $navbarcontent .= html_writer::tag('ul', join('', $htmlblocks), array('role'=>'navigation'));
2691         // XHTML
2692         return $navbarcontent;
2693     }
2695     /**
2696      * Renders a navigation node object.
2697      *
2698      * @param navigation_node $item The navigation node to render.
2699      * @return string HTML fragment
2700      */
2701     protected function render_navigation_node(navigation_node $item) {
2702         $content = $item->get_content();
2703         $title = $item->get_title();
2704         if ($item->icon instanceof renderable && !$item->hideicon) {
2705             $icon = $this->render($item->icon);
2706             $content = $icon.$content; // use CSS for spacing of icons
2707         }
2708         if ($item->helpbutton !== null) {
2709             $content = trim($item->helpbutton).html_writer::tag('span', $content, array('class'=>'clearhelpbutton', 'tabindex'=>'0'));
2710         }
2711         if ($content === '') {
2712             return '';
2713         }
2714         if ($item->action instanceof action_link) {
2715             $link = $item->action;
2716             if ($item->hidden) {
2717                 $link->add_class('dimmed');
2718             }
2719             if (!empty($content)) {
2720                 // Providing there is content we will use that for the link content.
2721                 $link->text = $content;
2722             }
2723             $content = $this->render($link);
2724         } else if ($item->action instanceof moodle_url) {
2725             $attributes = array();
2726             if ($title !== '') {
2727                 $attributes['title'] = $title;
2728             }
2729             if ($item->hidden) {
2730                 $attributes['class'] = 'dimmed_text';
2731             }
2732             $content = html_writer::link($item->action, $content, $attributes);
2734         } else if (is_string($item->action) || empty($item->action)) {
2735             $attributes = array('tabindex'=>'0'); //add tab support to span but still maintain character stream sequence.
2736             if ($title !== '') {
2737                 $attributes['title'] = $title;
2738             }
2739             if ($item->hidden) {
2740                 $attributes['class'] = 'dimmed_text';
2741             }
2742             $content = html_writer::tag('span', $content, $attributes);
2743         }
2744         return $content;
2745     }
2747     /**
2748      * Accessibility: Right arrow-like character is
2749      * used in the breadcrumb trail, course navigation menu
2750      * (previous/next activity), calendar, and search forum block.
2751      * If the theme does not set characters, appropriate defaults
2752      * are set automatically. Please DO NOT
2753      * use &lt; &gt; &raquo; - these are confusing for blind users.
2754      *
2755      * @return string
2756      */
2757     public function rarrow() {
2758         return $this->page->theme->rarrow;
2759     }
2761     /**
2762      * Accessibility: Right arrow-like character is
2763      * used in the breadcrumb trail, course navigation menu
2764      * (previous/next activity), calendar, and search forum block.
2765      * If the theme does not set characters, appropriate defaults
2766      * are set automatically. Please DO NOT
2767      * use &lt; &gt; &raquo; - these are confusing for blind users.
2768      *
2769      * @return string
2770      */
2771     public function larrow() {
2772         return $this->page->theme->larrow;
2773     }
2775     /**
2776      * Returns the custom menu if one has been set
2777      *
2778      * A custom menu can be configured by browsing to
2779      *    Settings: Administration > Appearance > Themes > Theme settings
2780      * and then configuring the custommenu config setting as described.
2781      *
2782      * @param string $custommenuitems - custom menuitems set by theme instead of global theme settings
2783      * @return string
2784      */
2785     public function custom_menu($custommenuitems = '') {
2786         global $CFG;
2787         if (empty($custommenuitems) && !empty($CFG->custommenuitems)) {
2788             $custommenuitems = $CFG->custommenuitems;
2789         }
2790         if (empty($custommenuitems)) {
2791             return '';
2792         }
2793         $custommenu = new custom_menu($custommenuitems, current_language());
2794         return $this->render_custom_menu($custommenu);
2795     }
2797     /**
2798      * Renders a custom menu object (located in outputcomponents.php)
2799      *
2800      * The custom menu this method produces makes use of the YUI3 menunav widget
2801      * and requires very specific html elements and classes.
2802      *
2803      * @staticvar int $menucount
2804      * @param custom_menu $menu
2805      * @return string
2806      */
2807     protected function render_custom_menu(custom_menu $menu) {
2808         static $menucount = 0;
2809         // If the menu has no children return an empty string
2810         if (!$menu->has_children()) {
2811             return '';
2812         }
2813         // Increment the menu count. This is used for ID's that get worked with
2814         // in JavaScript as is essential
2815         $menucount++;
2816         // Initialise this custom menu (the custom menu object is contained in javascript-static
2817         $jscode = js_writer::function_call_with_Y('M.core_custom_menu.init', array('custom_menu_'.$menucount));
2818         $jscode = "(function(){{$jscode}})";
2819         $this->page->requires->yui_module('node-menunav', $jscode);
2820         // Build the root nodes as required by YUI
2821         $content = html_writer::start_tag('div', array('id'=>'custom_menu_'.$menucount, 'class'=>'yui3-menu yui3-menu-horizontal javascript-disabled'));
2822         $content .= html_writer::start_tag('div', array('class'=>'yui3-menu-content'));
2823         $content .= html_writer::start_tag('ul');
2824         // Render each child
2825         foreach ($menu->get_children() as $item) {
2826             $content .= $this->render_custom_menu_item($item);
2827         }
2828         // Close the open tags
2829         $content .= html_writer::end_tag('ul');
2830         $content .= html_writer::end_tag('div');
2831         $content .= html_writer::end_tag('div');
2832         // Return the custom menu
2833         return $content;
2834     }
2836     /**
2837      * Renders a custom menu node as part of a submenu
2838      *
2839      * The custom menu this method produces makes use of the YUI3 menunav widget
2840      * and requires very specific html elements and classes.
2841      *
2842      * @see core:renderer::render_custom_menu()
2843      *
2844      * @staticvar int $submenucount
2845      * @param custom_menu_item $menunode
2846      * @return string
2847      */
2848     protected function render_custom_menu_item(custom_menu_item $menunode) {
2849         // Required to ensure we get unique trackable id's
2850         static $submenucount = 0;
2851         if ($menunode->has_children()) {
2852             // If the child has menus render it as a sub menu
2853             $submenucount++;
2854             $content = html_writer::start_tag('li');
2855             if ($menunode->get_url() !== null) {
2856                 $url = $menunode->get_url();
2857             } else {
2858                 $url = '#cm_submenu_'.$submenucount;
2859             }
2860             $content .= html_writer::link($url, $menunode->get_text(), array('class'=>'yui3-menu-label', 'title'=>$menunode->get_title()));
2861             $content .= html_writer::start_tag('div', array('id'=>'cm_submenu_'.$submenucount, 'class'=>'yui3-menu custom_menu_submenu'));
2862             $content .= html_writer::start_tag('div', array('class'=>'yui3-menu-content'));
2863             $content .= html_writer::start_tag('ul');
2864             foreach ($menunode->get_children() as $menunode) {
2865                 $content .= $this->render_custom_menu_item($menunode);
2866             }
2867             $content .= html_writer::end_tag('ul');
2868             $content .= html_writer::end_tag('div');
2869             $content .= html_writer::end_tag('div');
2870             $content .= html_writer::end_tag('li');
2871         } else {
2872             // The node doesn't have children so produce a final menuitem
2873             $content = html_writer::start_tag('li', array('class'=>'yui3-menuitem'));
2874             if ($menunode->get_url() !== null) {
2875                 $url = $menunode->get_url();
2876             } else {
2877                 $url = '#';
2878             }
2879             $content .= html_writer::link($url, $menunode->get_text(), array('class'=>'yui3-menuitem-content', 'title'=>$menunode->get_title()));
2880             $content .= html_writer::end_tag('li');
2881         }
2882         // Return the sub menu
2883         return $content;
2884     }
2886     /**
2887      * Renders theme links for switching between default and other themes.
2888      *
2889      * @return string
2890      */
2891     protected function theme_switch_links() {
2893         $actualdevice = get_device_type();
2894         $currentdevice = $this->page->devicetypeinuse;
2895         $switched = ($actualdevice != $currentdevice);
2897         if (!$switched && $currentdevice == 'default' && $actualdevice == 'default') {
2898             // The user is using the a default device and hasn't switched so don't shown the switch
2899             // device links.
2900             return '';
2901         }
2903         if ($switched) {
2904             $linktext = get_string('switchdevicerecommended');
2905             $devicetype = $actualdevice;
2906         } else {
2907             $linktext = get_string('switchdevicedefault');
2908             $devicetype = 'default';
2909         }
2910         $linkurl = new moodle_url('/theme/switchdevice.php', array('url' => $this->page->url, 'device' => $devicetype, 'sesskey' => sesskey()));
2912         $content  = html_writer::start_tag('div', array('id' => 'theme_switch_link'));
2913         $content .= html_writer::link($linkurl, $linktext);
2914         $content .= html_writer::end_tag('div');
2916         return $content;
2917     }
2920 /**
2921  * A renderer that generates output for command-line scripts.
2922  *
2923  * The implementation of this renderer is probably incomplete.
2924  *
2925  * @copyright 2009 Tim Hunt
2926  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
2927  * @since Moodle 2.0
2928  * @package core
2929  * @category output
2930  */
2931 class core_renderer_cli extends core_renderer {
2933     /**
2934      * Returns the page header.
2935      *
2936      * @return string HTML fragment
2937      */
2938     public function header() {
2939         return $this->page->heading . "\n";
2940     }
2942     /**
2943      * Returns a template fragment representing a Heading.
2944      *
2945      * @param string $text The text of the heading
2946      * @param int $level The level of importance of the heading
2947      * @param string $classes A space-separated list of CSS classes
2948      * @param string $id An optional ID
2949      * @return string A template fragment for a heading
2950      */
2951     public function heading($text, $level = 2, $classes = 'main', $id = null) {
2952         $text .= "\n";
2953         switch ($level) {
2954             case 1:
2955                 return '=>' . $text;
2956             case 2:
2957                 return '-->' . $text;
2958             default:
2959                 return $text;
2960         }
2961     }
2963     /**
2964      * Returns a template fragment representing a fatal error.
2965      *
2966      * @param string $message The message to output
2967      * @param string $moreinfourl URL where more info can be found about the error
2968      * @param string $link Link for the Continue button
2969      * @param array $backtrace The execution backtrace
2970      * @param string $debuginfo Debugging information
2971      * @return string A template fragment for a fatal error
2972      */
2973     public function fatal_error($message, $moreinfourl, $link, $backtrace, $debuginfo = null) {
2974         $output = "!!! $message !!!\n";
2976         if (debugging('', DEBUG_DEVELOPER)) {
2977             if (!empty($debuginfo)) {
2978                 $output .= $this->notification($debuginfo, 'notifytiny');
2979             }
2980             if (!empty($backtrace)) {
2981                 $output .= $this->notification('Stack trace: ' . format_backtrace($backtrace, true), 'notifytiny');
2982             }
2983         }
2985         return $output;
2986     }
2988     /**
2989      * Returns a template fragment representing a notification.
2990      *
2991      * @param string $message The message to include
2992      * @param string $classes A space-separated list of CSS classes
2993      * @return string A template fragment for a notification
2994      */
2995     public function notification($message, $classes = 'notifyproblem') {
2996         $message = clean_text($message);
2997         if ($classes === 'notifysuccess') {
2998             return "++ $message ++\n";
2999         }
3000         return "!! $message !!\n";
3001     }
3005 /**
3006  * A renderer that generates output for ajax scripts.
3007  *
3008  * This renderer prevents accidental sends back only json
3009  * encoded error messages, all other output is ignored.
3010  *
3011  * @copyright 2010 Petr Skoda
3012  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
3013  * @since Moodle 2.0
3014  * @package core
3015  * @category output
3016  */
3017 class core_renderer_ajax extends core_renderer {
3019     /**
3020      * Returns a template fragment representing a fatal error.
3021      *
3022      * @param string $message The message to output
3023      * @param string $moreinfourl URL where more info can be found about the error
3024      * @param string $link Link for the Continue button
3025      * @param array $backtrace The execution backtrace
3026      * @param string $debuginfo Debugging information
3027      * @return string A template fragment for a fatal error
3028      */
3029     public function fatal_error($message, $moreinfourl, $link, $backtrace, $debuginfo = null) {
3030         global $CFG;
3032         $this->page->set_context(null); // ugly hack - make sure page context is set to something, we do not want bogus warnings here
3034         $e = new stdClass();
3035         $e->error      = $message;
3036         $e->stacktrace = NULL;
3037         $e->debuginfo  = NULL;
3038         $e->reproductionlink = NULL;
3039         if (!empty($CFG->debug) and $CFG->debug >= DEBUG_DEVELOPER) {
3040             $e->reproductionlink = $link;
3041             if (!empty($debuginfo)) {
3042                 $e->debuginfo = $debuginfo;
3043             }
3044             if (!empty($backtrace)) {
3045                 $e->stacktrace = format_backtrace($backtrace, true);
3046             }
3047         }
3048         $this->header();
3049         return json_encode($e);
3050     }
3052     /**
3053      * Used to display a notification.
3054      * For the AJAX notifications are discarded.
3055      *
3056      * @param string $message
3057      * @param string $classes
3058      */
3059     public function notification($message, $classes = 'notifyproblem') {}
3061     /**
3062      * Used to display a redirection message.
3063      * AJAX redirections should not occur and as such redirection messages
3064      * are discarded.
3065      *
3066      * @param moodle_url|string $encodedurl
3067      * @param string $message
3068      * @param int $delay
3069      * @param bool $debugdisableredirect
3070      */
3071     public function redirect_message($encodedurl, $message, $delay, $debugdisableredirect) {}
3073     /**
3074      * Prepares the start of an AJAX output.
3075      */
3076     public function header() {
3077         // unfortunately YUI iframe upload does not support application/json
3078         if (!empty($_FILES)) {
3079             @header('Content-type: text/plain; charset=utf-8');
3080         } else {
3081             @header('Content-type: application/json; charset=utf-8');
3082         }
3084         // Headers to make it not cacheable and json
3085         @header('Cache-Control: no-store, no-cache, must-revalidate');
3086         @header('Cache-Control: post-check=0, pre-check=0', false);
3087         @header('Pragma: no-cache');
3088         @header('Expires: Mon, 20 Aug 1969 09:23:00 GMT');
3089         @header('Last-Modified: ' . gmdate('D, d M Y H:i:s') . ' GMT');
3090         @header('Accept-Ranges: none');
3091     }
3093     /**
3094      * There is no footer for an AJAX request, however we must override the
3095      * footer method to prevent the default footer.
3096      */
3097     public function footer() {}
3099     /**
3100      * No need for headers in an AJAX request... this should never happen.
3101      * @param string $text
3102      * @param int $level
3103      * @param string $classes
3104      * @param string $id
3105      */
3106     public function heading($text, $level = 2, $classes = 'main', $id = null) {}
3110 /**
3111  * Renderer for media files.
3112  *
3113  * Used in file resources, media filter, and any other places that need to
3114  * output embedded media.
3115  *
3116  * @copyright 2011 The Open University
3117  * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
3118  */
3119 class core_media_renderer extends plugin_renderer_base {
3120     /** @var array Array of available 'player' objects */
3121     private $players;
3122     /** @var string Regex pattern for links which may contain embeddable content */
3123     private $embeddablemarkers;
3125     /**
3126      * Constructor requires medialib.php.
3127      *
3128      * This is needed in the constructor (not later) so that you can use the
3129      * constants and static functions that are defined in core_media class
3130      * before you call renderer functions.
3131      */
3132     public function __construct() {
3133         global $CFG;
3134         require_once($CFG->libdir . '/medialib.php');
3135     }
3137     /**
3138      * Obtains the list of core_media_player objects currently in use to render
3139      * items.
3140      *
3141      * The list is in rank order (highest first) and does not include players
3142      * which are disabled.
3143      *
3144      * @return array Array of core_media_player objects in rank order
3145      */
3146     protected function get_players() {
3147         global $CFG;
3149         // Save time by only building the list once.
3150         if (!$this->players) {
3151             // Get raw list of players.
3152             $players = $this->get_players_raw();
3154             // Chuck all the ones that are disabled.
3155             foreach ($players as $key => $player) {
3156                 if (!$player->is_enabled()) {
3157                     unset($players[$key]);
3158                 }
3159             }
3161             // Sort in rank order (highest first).
3162             usort($players, array('core_media_player', 'compare_by_rank'));
3163             $this->players = $players;
3164         }
3165         return $this->players;
3166     }
3168     /**
3169      * Obtains a raw list of player objects that includes objects regardless
3170      * of whether they are disabled or not, and without sorting.
3171      *
3172      * You can override this in a subclass if you need to add additional
3173      * players.
3174      *
3175      * The return array is be indexed by player name to make it easier to
3176      * remove players in a subclass.
3177      *
3178      * @return array $players Array of core_media_player objects in any order
3179      */
3180     protected function get_players_raw() {
3181         return array(
3182             'vimeo' => new core_media_player_vimeo(),
3183             'youtube' => new core_media_player_youtube(),
3184             'youtube_playlist' => new core_media_player_youtube_playlist(),
3185             'html5video' => new core_media_player_html5video(),
3186             'html5audio' => new core_media_player_html5audio(),
3187             'mp3' => new core_media_player_mp3(),
3188             'flv' => new core_media_player_flv(),
3189             'wmp' => new core_media_player_wmp(),
3190             'qt' => new core_media_player_qt(),
3191             'rm' => new core_media_player_rm(),
3192             'swf' => new core_media_player_swf(),
3193             'link' => new core_media_player_link(),
3194         );
3195     }
3197     /**
3198      * Renders a media file (audio or video) using suitable embedded player.
3199      *
3200      * See embed_alternatives function for full description of parameters.
3201      * This function calls through to that one.
3202      *
3203      * When using this function you can also specify width and height in the
3204      * URL by including ?d=100x100 at the end. If specified in the URL, this
3205      * will override the $width and $height parameters.
3206      *
3207      * @param moodle_url $url Full URL of media file
3208      * @param string $name Optional user-readable name to display in download link
3209      * @param int $width Width in pixels (optional)
3210      * @param int $height Height in pixels (optional)
3211      * @param array $options Array of key/value pairs
3212      * @return string HTML content of embed
3213      */
3214     public function embed_url(moodle_url $url, $name = '', $width = 0, $height = 0,
3215             $options = array()) {
3217         // Get width and height from URL if specified (overrides parameters in
3218         // function call).
3219         $rawurl = $url->out(false);
3220         if (preg_match('/[?#]d=([\d]{1,4}%?)x([\d]{1,4}%?)/', $rawurl, $matches)) {
3221             $width = $matches[1];
3222             $height = $matches[2];
3223             $url = new moodle_url(str_replace($matches[0], '', $rawurl));
3224         }
3226         // Defer to array version of function.
3227         return $this->embed_alternatives(array($url), $name, $width, $height, $options);
3228     }
3230     /**
3231      * Renders media files (audio or video) using suitable embedded player.
3232      * The list of URLs should be alternative versions of the same content in
3233      * multiple formats. If there is only one format it should have a single
3234      * entry.
3235      *
3236      * If the media files are not in a supported format, this will give students
3237      * a download link to each format. The download link uses the filename
3238      * unless you supply the optional name parameter.
3239      *
3240      * Width and height are optional. If specified, these are suggested sizes
3241      * and should be the exact values supplied by the user, if they come from
3242      * user input. These will be treated as relating to the size of the video
3243      * content, not including any player control bar.
3244      *
3245      * For audio files, height will be ignored. For video files, a few formats
3246      * work if you specify only width, but in general if you specify width
3247      * you must specify height as well.
3248      *
3249      * The $options array is passed through to the core_media_player classes
3250      * that render the object tag. The keys can contain values from
3251      * core_media::OPTION_xx.
3252      *
3253      * @param array $alternatives Array of moodle_url to media files
3254      * @param string $name Optional user-readable name to display in download link
3255      * @param int $width Width in pixels (optional)
3256      * @param int $height Height in pixels (optional)
3257      * @param array $options Array of key/value pairs
3258      * @return string HTML content of embed
3259      */
3260     public function embed_alternatives($alternatives, $name = '', $width = 0, $height = 0,
3261             $options = array()) {
3263         // Get list of player plugins (will also require the library).
3264         $players = $this->get_players();
3266         // Set up initial text which will be replaced by first player that
3267         // supports any of the formats.
3268         $out = core_media_player::PLACEHOLDER;
3270         // Loop through all players that support any of these URLs.
3271         foreach ($players as $player) {
3272             // Option: When no other player matched, don't do the default link player.
3273             if (!empty($options[core_media::OPTION_FALLBACK_TO_BLANK]) &&
3274                     $player->get_rank() === 0 && $out === core_media_player::PLACEHOLDER) {
3275                 continue;
3276             }
3278             $supported = $player->list_supported_urls($alternatives, $options);
3279             if ($supported) {
3280                 // Embed.
3281                 $text = $player->embed($supported, $name, $width, $height, $options);
3283                 // Put this in place of the 'fallback' slot in the previous text.
3284                 $out = str_replace(core_media_player::PLACEHOLDER, $text, $out);
3285             }
3286         }
3288         // Remove 'fallback' slot from final version and return it.
3289         $out = str_replace(core_media_player::PLACEHOLDER, '', $out);
3290         if (!empty($options[core_media::OPTION_BLOCK]) && $out !== '') {
3291             $out = html_writer::tag('div', $out, array('class' => 'resourcecontent'));
3292         }
3293         return $out;
3294     }
3296     /**
3297      * Checks whether a file can be embedded. If this returns true you will get
3298      * an embedded player; if this returns false, you will just get a download
3299      * link.
3300      *
3301      * This is a wrapper for can_embed_urls.
3302      *
3303      * @param moodle_url $url URL of media file
3304      * @param array $options Options (same as when embedding)
3305      * @return bool True if file can be embedded
3306      */
3307     public function can_embed_url(moodle_url $url, $options = array()) {
3308         return $this->can_embed_urls(array($url), $options);
3309     }
3311     /**
3312      * Checks whether a file can be embedded. If this returns true you will get
3313      * an embedded player; if this returns false, you will just get a download
3314      * link.
3315      *
3316      * @param array $urls URL of media file and any alternatives (moodle_url)
3317      * @param array $options Options (same as when embedding)
3318      * @return bool True if file can be embedded
3319      */
3320     public function can_embed_urls(array $urls, $options = array()) {
3321         // Check all players to see if any of them support it.
3322         foreach ($this->get_players() as $player) {
3323             // Link player (always last on list) doesn't count!
3324             if ($player->get_rank() <= 0) {
3325                 break;
3326             }
3327             // First player that supports it, return true.
3328             if ($player->list_supported_urls($urls, $options)) {
3329                 return true;
3330             }
3331         }
3332         return false;
3333     }
3335     /**
3336      * Obtains a list of markers that can be used in a regular expression when
3337      * searching for URLs that can be embedded by any player type.
3338      *
3339      * This string is used to improve peformance of regex matching by ensuring
3340      * that the (presumably C) regex code can do a quick keyword check on the
3341      * URL part of a link to see if it matches one of these, rather than having
3342      * to go into PHP code for every single link to see if it can be embedded.
3343      *
3344      * @return string String suitable for use in regex such as '(\.mp4|\.flv)'
3345      */
3346     public function get_embeddable_markers() {
3347         if (empty($this->embeddablemarkers)) {
3348             $markers = '';
3349             foreach ($this->get_players() as $player) {
3350                 foreach ($player->get_embeddable_markers() as $marker) {
3351                     if ($markers !== '') {
3352                         $markers .= '|';
3353                     }
3354                     $markers .= preg_quote($marker);
3355                 }
3356             }
3357             $this->embeddablemarkers = $markers;
3358         }
3359         return $this->embeddablemarkers;
3360     }