Proyectos de Subversion Moodle

<?php

// This file is part of Moodle - http://moodle.org/

//

// Moodle is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// Moodle is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

/**

 * Classes for rendering HTML output for Moodle.

 *

 * Please see {@link http://docs.moodle.org/en/Developement:How_Moodle_outputs_HTML}

 * for an overview.

 *

 * Included in this file are the primary renderer classes:

 *     - renderer_base:         The renderer outline class that all renderers

 *                              should inherit from.

 *     - core_renderer:         The standard HTML renderer.

 *     - core_renderer_cli:     An adaption of the standard renderer for CLI scripts.

 *     - core_renderer_ajax:    An adaption of the standard renderer for AJAX scripts.

 *     - plugin_renderer_base:  A renderer class that should be extended by all

 *                              plugin renderers.

 *

 * @package core

 * @category output

 * @copyright  2009 Tim Hunt

 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

use core\di;

use core\hook\manager as hook_manager;

use core\hook\output\after_standard_main_region_html_generation;

use core\hook\output\before_footer_html_generation;

use core\hook\output\before_html_attributes;

use core\hook\output\before_http_headers;

use core\hook\output\before_standard_footer_html_generation;

use core\hook\output\before_standard_top_of_body_html_generation;

use core\output\named_templatable;

use core_completion\cm_completion_details;

use core_course\output\activity_information;

defined('MOODLE_INTERNAL') || die();

/**

 * Simple base class for Moodle renderers.

 *

 * Tracks the xhtml_container_stack to use, which is passed in in the constructor.

 *

 * Also has methods to facilitate generating HTML output.

 *

 * @copyright 2009 Tim Hunt

 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 * @since Moodle 2.0

 * @package core

 * @category output

 */

class renderer_base {

    /**

     * @var xhtml_container_stack The xhtml_container_stack to use.

     */

    protected $opencontainers;

    /**

     * @var moodle_page The Moodle page the renderer has been created to assist with.

     */

    protected $page;

    /**

     * @var string The requested rendering target.

     */

    protected $target;

    /**

     * @var Mustache_Engine $mustache The mustache template compiler

     */

    private $mustache;

    /**

     * @var array $templatecache The mustache template cache.

     */

    protected $templatecache = [];

    /**

     * Return an instance of the mustache class.

     *

     * @since 2.9

     * @return Mustache_Engine

     */

    protected function get_mustache() {

        global $CFG;

        if ($this->mustache === null) {

            require_once("{$CFG->libdir}/filelib.php");

            $themename = $this->page->theme->name;

            $themerev = theme_get_revision();

            // Create new localcache directory.

            $cachedir = make_localcache_directory("mustache/$themerev/$themename");

            // Remove old localcache directories.

            $mustachecachedirs = glob("{$CFG->localcachedir}/mustache/*", GLOB_ONLYDIR);

            foreach ($mustachecachedirs as $localcachedir) {

                $cachedrev = [];

                preg_match("/\/mustache\/([0-9]+)$/", $localcachedir, $cachedrev);

                $cachedrev = isset($cachedrev[1]) ? intval($cachedrev[1]) : 0;

                if ($cachedrev > 0 && $cachedrev < $themerev) {

                    fulldelete($localcachedir);

                }

            }

            $loader = new \core\output\mustache_filesystem_loader();

            $stringhelper = new \core\output\mustache_string_helper();

            $cleanstringhelper = new \core\output\mustache_clean_string_helper();

            $quotehelper = new \core\output\mustache_quote_helper();

            $jshelper = new \core\output\mustache_javascript_helper($this->page);

            $pixhelper = new \core\output\mustache_pix_helper($this);

            $shortentexthelper = new \core\output\mustache_shorten_text_helper();

            $userdatehelper = new \core\output\mustache_user_date_helper();

            // We only expose the variables that are exposed to JS templates.

            $safeconfig = $this->page->requires->get_config_for_javascript($this->page, $this);

            $helpers = array('config' => $safeconfig,

                             'str' => array($stringhelper, 'str'),

                             'cleanstr' => array($cleanstringhelper, 'cleanstr'),

                             'quote' => array($quotehelper, 'quote'),

                             'js' => array($jshelper, 'help'),

                             'pix' => array($pixhelper, 'pix'),

                             'shortentext' => array($shortentexthelper, 'shorten'),

                             'userdate' => array($userdatehelper, 'transform'),

                         );

            $this->mustache = new \core\output\mustache_engine(array(

                'cache' => $cachedir,

                'escape' => 's',

                'loader' => $loader,

                'helpers' => $helpers,

                'pragmas' => [Mustache_Engine::PRAGMA_BLOCKS],

                // Don't allow the JavaScript helper to be executed from within another

                // helper. If it's allowed it can be used by users to inject malicious

                // JS into the page.

                'disallowednestedhelpers' => ['js'],

                // Disable lambda rendering - content in helpers is already rendered, no need to render it again.

                'disable_lambda_rendering' => true,

            ));

        }

        return $this->mustache;

    }

    /**

     * Constructor

     *

     * The constructor takes two arguments. The first is the page that the renderer

     * has been created to assist with, and the second is the target.

     * The target is an additional identifier that can be used to load different

     * renderers for different options.

     *

     * @param moodle_page $page the page we are doing output for.

     * @param string $target one of rendering target constants

     */

    public function __construct(moodle_page $page, $target) {

        $this->opencontainers = $page->opencontainers;

        $this->page = $page;

        $this->target = $target;

    }

    /**

     * Renders a template by name with the given context.

     *

     * The provided data needs to be array/stdClass made up of only simple types.

     * Simple types are array,stdClass,bool,int,float,string

     *

     * @since 2.9

     * @param array|stdClass $context Context containing data for the template.

     * @return string|boolean

     */

    public function render_from_template($templatename, $context) {

        $mustache = $this->get_mustache();

        if ($mustache->hasHelper('uniqid')) {

            // Grab a copy of the existing helper to be restored later.

            $uniqidhelper = $mustache->getHelper('uniqid');

        } else {

            // Helper doesn't exist.

            $uniqidhelper = null;

        }

        // Provide 1 random value that will not change within a template

        // but will be different from template to template. This is useful for

        // e.g. aria attributes that only work with id attributes and must be

        // unique in a page.

        $mustache->addHelper('uniqid', new \core\output\mustache_uniqid_helper());

        if (isset($this->templatecache[$templatename])) {

            $template = $this->templatecache[$templatename];

        } else {

            try {

                $template = $mustache->loadTemplate($templatename);

                $this->templatecache[$templatename] = $template;

            } catch (Mustache_Exception_UnknownTemplateException $e) {

                throw new moodle_exception('Unknown template: ' . $templatename);

            }

        }

        $renderedtemplate = trim($template->render($context));

        // If we had an existing uniqid helper then we need to restore it to allow

        // handle nested calls of render_from_template.

        if ($uniqidhelper) {

            $mustache->addHelper('uniqid', $uniqidhelper);

        }

        return $renderedtemplate;

    }

    /**

     * Returns rendered widget.

     *

     * The provided widget needs to be an object that extends the renderable

     * interface.

     * If will then be rendered by a method based upon the classname for the widget.

     * For instance a widget of class `crazywidget` will be rendered by a protected

     * render_crazywidget method of this renderer.

     * If no render_crazywidget method exists and crazywidget implements templatable,

     * look for the 'crazywidget' template in the same component and render that.

     *

     * @param renderable $widget instance with renderable interface

     * @return string

     */

    public function render(renderable $widget) {

        $classparts = explode('\\', get_class($widget));

        // Strip namespaces.

        $classname = array_pop($classparts);

        // Remove _renderable suffixes.

        $classname = preg_replace('/_renderable$/', '', $classname);

        $rendermethod = "render_{$classname}";

        if (method_exists($this, $rendermethod)) {

            // Call the render_[widget_name] function.

            // Note: This has a higher priority than the named_templatable to allow the theme to override the template.

            return $this->$rendermethod($widget);

        }

        if ($widget instanceof named_templatable) {

            // This is a named templatable.

            // Fetch the template name from the get_template_name function instead.

            // Note: This has higher priority than the guessed template name.

            return $this->render_from_template(

                $widget->get_template_name($this),

                $widget->export_for_template($this)

            );

        }

        if ($widget instanceof templatable) {

            // Guess the templat ename based on the class name.

            // Note: There's no benefit to moving this aboved the named_templatable and this approach is more costly.

            $component = array_shift($classparts);

            if (!$component) {

                $component = 'core';

            }

            $template = $component . '/' . $classname;

            $context = $widget->export_for_template($this);

            return $this->render_from_template($template, $context);

        }

        throw new coding_exception("Can not render widget, renderer method ('{$rendermethod}') not found.");

    }

    /**

     * Adds a JS action for the element with the provided id.

     *

     * This method adds a JS event for the provided component action to the page

     * and then returns the id that the event has been attached to.

     * If no id has been provided then a new ID is generated by {@link html_writer::random_id()}

     *

     * @param component_action $action

     * @param string $id

     * @return string id of element, either original submitted or random new if not supplied

     */

    public function add_action_handler(component_action $action, $id = null) {

        if (!$id) {

            $id = html_writer::random_id($action->event);

        }

        $this->page->requires->event_handler("#$id", $action->event, $action->jsfunction, $action->jsfunctionargs);

        return $id;

    }

    /**

     * Returns true is output has already started, and false if not.

     *

     * @return boolean true if the header has been printed.

     */

    public function has_started() {

        return $this->page->state >= moodle_page::STATE_IN_BODY;

    }

    /**

     * Given an array or space-separated list of classes, prepares and returns the HTML class attribute value

     *

     * @param mixed $classes Space-separated string or array of classes

     * @return string HTML class attribute value

     */

    public static function prepare_classes($classes) {

        if (is_array($classes)) {

            return implode(' ', array_unique($classes));

        }

        return $classes;

    }

    /**

     * Return the direct URL for an image from the pix folder.

     *

     * Use this function sparingly and never for icons. For icons use pix_icon or the pix helper in a mustache template.

     *

     * @deprecated since Moodle 3.3

     * @param string $imagename the name of the icon.

     * @param string $component specification of one plugin like in get_string()

     * @return moodle_url

     */

    public function pix_url($imagename, $component = 'moodle') {

        debugging('pix_url is deprecated. Use image_url for images and pix_icon for icons.', DEBUG_DEVELOPER);

        return $this->page->theme->image_url($imagename, $component);

    }

    /**

     * Return the moodle_url for an image.

     *

     * The exact image location and extension is determined

     * automatically by searching for gif|png|jpg|jpeg, please

     * note there can not be diferent images with the different

     * extension. The imagename is for historical reasons

     * a relative path name, it may be changed later for core

     * images. It is recommended to not use subdirectories

     * in plugin and theme pix directories.

     *

     * There are three types of images:

     * 1/ theme images  - stored in theme/mytheme/pix/,

     *                    use component 'theme'

     * 2/ core images   - stored in /pix/,

     *                    overridden via theme/mytheme/pix_core/

     * 3/ plugin images - stored in mod/mymodule/pix,

     *                    overridden via theme/mytheme/pix_plugins/mod/mymodule/,

     *                    example: image_url('comment', 'mod_glossary')

     *

     * @param string $imagename the pathname of the image

     * @param string $component full plugin name (aka component) or 'theme'

     * @return moodle_url

     */

    public function image_url($imagename, $component = 'moodle') {

        return $this->page->theme->image_url($imagename, $component);

    }

    /**

     * Return the site's logo URL, if any.

     *

     * @param int $maxwidth The maximum width, or null when the maximum width does not matter.

     * @param int $maxheight The maximum height, or null when the maximum height does not matter.

     * @return moodle_url|false

     */

    public function get_logo_url($maxwidth = null, $maxheight = 200) {

        global $CFG;

        $logo = get_config('core_admin', 'logo');

        if (empty($logo)) {

            return false;

        }

        // 200px high is the default image size which should be displayed at 100px in the page to account for retina displays.

        // It's not worth the overhead of detecting and serving 2 different images based on the device.

        // Hide the requested size in the file path.

        $filepath = ((int) $maxwidth . 'x' . (int) $maxheight) . '/';

        // Use $CFG->themerev to prevent browser caching when the file changes.

        return moodle_url::make_pluginfile_url(context_system::instance()->id, 'core_admin', 'logo', $filepath,

            theme_get_revision(), $logo);

    }

    /**

     * Return the site's compact logo URL, if any.

     *

     * @param int $maxwidth The maximum width, or null when the maximum width does not matter.

     * @param int $maxheight The maximum height, or null when the maximum height does not matter.

     * @return moodle_url|false

     */

    public function get_compact_logo_url($maxwidth = 300, $maxheight = 300) {

        global $CFG;

        $logo = get_config('core_admin', 'logocompact');

        if (empty($logo)) {

            return false;

        }

        // Hide the requested size in the file path.

        $filepath = ((int) $maxwidth . 'x' . (int) $maxheight) . '/';

        // Use $CFG->themerev to prevent browser caching when the file changes.

        return moodle_url::make_pluginfile_url(context_system::instance()->id, 'core_admin', 'logocompact', $filepath,

            theme_get_revision(), $logo);

    }

    /**

     * Whether we should display the logo in the navbar.

     *

     * We will when there are no main logos, and we have compact logo.

     *

     * @return bool

     */

    public function should_display_navbar_logo() {

        $logo = $this->get_compact_logo_url();

        return !empty($logo);

    }

    /**

     * Whether we should display the main logo.

     * @deprecated since Moodle 4.0

     * @todo final deprecation. To be removed in Moodle 4.4 MDL-73165.

     * @param int $headinglevel The heading level we want to check against.

     * @return bool

     */

    public function should_display_main_logo($headinglevel = 1) {

        debugging('should_display_main_logo() is deprecated and will be removed in Moodle 4.4.', DEBUG_DEVELOPER);

        // Only render the logo if we're on the front page or login page and the we have a logo.

        $logo = $this->get_logo_url();

        if ($headinglevel == 1 && !empty($logo)) {

            if ($this->page->pagelayout == 'frontpage' || $this->page->pagelayout == 'login') {

                return true;

            }

        }

        return false;

    }

    /**

     * Returns the moodle page object.

     *

     * @return moodle_page

     */

    public function get_page(): moodle_page {

        return $this->page;

    }

}

/**

 * Basis for all plugin renderers.

 *

 * @copyright Petr Skoda (skodak)

 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 * @since Moodle 2.0

 * @package core

 * @category output

 */

class plugin_renderer_base extends renderer_base {

    /**

     * @var renderer_base|core_renderer A reference to the current renderer.

     * The renderer provided here will be determined by the page but will in 90%

     * of cases by the {@link core_renderer}

     */

    protected $output;

    /**

     * Constructor method, calls the parent constructor

     *

     * @param moodle_page $page

     * @param string $target one of rendering target constants

     */

    public function __construct(moodle_page $page, $target) {

        if (empty($target) && $page->pagelayout === 'maintenance') {

            // If the page is using the maintenance layout then we're going to force the target to maintenance.

            // This way we'll get a special maintenance renderer that is designed to block access to API's that are likely

            // unavailable for this page layout.

            $target = RENDERER_TARGET_MAINTENANCE;

        }

        $this->output = $page->get_renderer('core', null, $target);

        parent::__construct($page, $target);

    }

    /**

     * Renders the provided widget and returns the HTML to display it.

     *

     * @param renderable $widget instance with renderable interface

     * @return string

     */

    public function render(renderable $widget) {

        $classname = get_class($widget);

        // Strip namespaces.

        $classname = preg_replace('/^.*\\\/', '', $classname);

        // Keep a copy at this point, we may need to look for a deprecated method.

        $deprecatedmethod = "render_{$classname}";

        // Remove _renderable suffixes.

        $classname = preg_replace('/_renderable$/', '', $classname);

        $rendermethod = "render_{$classname}";

        if (method_exists($this, $rendermethod)) {

            // Call the render_[widget_name] function.

            // Note: This has a higher priority than the named_templatable to allow the theme to override the template.

            return $this->$rendermethod($widget);

        }

        if ($widget instanceof named_templatable) {

            // This is a named templatable.

            // Fetch the template name from the get_template_name function instead.

            // Note: This has higher priority than the deprecated method which is not overridable by themes anyway.

            return $this->render_from_template(

                $widget->get_template_name($this),

                $widget->export_for_template($this)

            );

        }

        if ($rendermethod !== $deprecatedmethod && method_exists($this, $deprecatedmethod)) {

            // This is exactly where we don't want to be.

            // If you have arrived here you have a renderable component within your plugin that has the name

            // blah_renderable, and you have a render method render_blah_renderable on your plugin.

            // In 2.8 we revamped output, as part of this change we changed slightly how renderables got rendered

            // and the _renderable suffix now gets removed when looking for a render method.

            // You need to change your renderers render_blah_renderable to render_blah.

            // Until you do this it will not be possible for a theme to override the renderer to override your method.

            // Please do it ASAP.

            static $debugged = [];

            if (!isset($debugged[$deprecatedmethod])) {

                debugging(sprintf(

                    'Deprecated call. Please rename your renderables render method from %s to %s.',

                    $deprecatedmethod,

                    $rendermethod

                ), DEBUG_DEVELOPER);

                $debugged[$deprecatedmethod] = true;

            }

            return $this->$deprecatedmethod($widget);

        }

        // Pass to core renderer if method not found here.

        // Note: this is not a parent. This is _new_ renderer which respects the requested format, and output type.

        return $this->output->render($widget);

    }

    /**

     * Magic method used to pass calls otherwise meant for the standard renderer

     * to it to ensure we don't go causing unnecessary grief.

     *

     * @param string $method

     * @param array $arguments

     * @return mixed

     */

    public function __call($method, $arguments) {

        if (method_exists('renderer_base', $method)) {

            throw new coding_exception('Protected method called against '.get_class($this).' :: '.$method);

        }

        if (method_exists($this->output, $method)) {

            return call_user_func_array(array($this->output, $method), $arguments);

        } else {

            throw new coding_exception('Unknown method called against '.get_class($this).' :: '.$method);

        }

    }

}

/**

 * The standard implementation of the core_renderer interface.

 *

 * @copyright 2009 Tim Hunt

 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 * @since Moodle 2.0

 * @package core

 * @category output

 */

class core_renderer extends renderer_base {

    /**

     * Do NOT use, please use <?php echo $OUTPUT->main_content() ?>

     * in layout files instead.

     * @deprecated

     * @var string used in {@link core_renderer::header()}.

     */

    const MAIN_CONTENT_TOKEN = '[MAIN CONTENT GOES HERE]';

    /**

     * @var string Used to pass information from {@link core_renderer::doctype()} to

     * {@link core_renderer::standard_head_html()}.

     */

    protected $contenttype;

    /**

     * @var string Used by {@link core_renderer::redirect_message()} method to communicate

     * with {@link core_renderer::header()}.

     */

    protected $metarefreshtag = '';

    /**

     * @var string Unique token for the closing HTML

     */

    protected $unique_end_html_token;

    /**

     * @var string Unique token for performance information

     */

    protected $unique_performance_info_token;

    /**

     * @var string Unique token for the main content.

     */

    protected $unique_main_content_token;

    /** @var custom_menu_item language The language menu if created */

    protected $language = null;

    /** @var string The current selector for an element being streamed into */

    protected $currentselector = '';

    /** @var string The current element tag which is being streamed into */

    protected $currentelement = '';

    /**

     * Constructor

     *

     * @param moodle_page $page the page we are doing output for.

     * @param string $target one of rendering target constants

     */

    public function __construct(moodle_page $page, $target) {

        $this->opencontainers = $page->opencontainers;

        $this->page = $page;

        $this->target = $target;

        $this->unique_end_html_token = '%%ENDHTML-'.sesskey().'%%';

        $this->unique_performance_info_token = '%%PERFORMANCEINFO-'.sesskey().'%%';

        $this->unique_main_content_token = '[MAIN CONTENT GOES HERE - '.sesskey().']';

    }

    /**

     * Get the DOCTYPE declaration that should be used with this page. Designed to

     * be called in theme layout.php files.

     *

     * @return string the DOCTYPE declaration that should be used.

     */

    public function doctype() {

        if ($this->page->theme->doctype === 'html5') {

            $this->contenttype = 'text/html; charset=utf-8';

            return "<!DOCTYPE html>\n";

        } else if ($this->page->theme->doctype === 'xhtml5') {

            $this->contenttype = 'application/xhtml+xml; charset=utf-8';

            return "<!DOCTYPE html>\n";

        } else {

            // legacy xhtml 1.0

            $this->contenttype = 'text/html; charset=utf-8';

            return ('<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">' . "\n");

        }

    }

    /**

     * The attributes that should be added to the <html> tag. Designed to

     * be called in theme layout.php files.

     *

     * @return string HTML fragment.

     */

    public function htmlattributes() {

        $return = get_html_lang(true);

        // Ensure that the callback exists prior to cache purge.

        // This is a critical page path.

        // TODO MDL-81134 Remove after LTS+1.

        require_once(__DIR__ . '/classes/hook/output/before_html_attributes.php');

        $hook = new before_html_attributes($this);

        if ($this->page->theme->doctype !== 'html5') {

            $hook->add_attribute('xmlns', 'http://www.w3.org/1999/xhtml');

        }

        $hook->process_legacy_callbacks();

        di::get(hook_manager::class)->dispatch($hook);

        foreach ($hook->get_attributes() as $key => $val) {

            $val = s($val);

            $return .= " $key=\"$val\"";

        }

        return $return;

    }

    /**

     * The standard tags (meta tags, links to stylesheets and JavaScript, etc.)

     * that should be included in the <head> tag. Designed to be called in theme

     * layout.php files.

     *

     * @return string HTML fragment.

     */

    public function standard_head_html() {

        global $CFG, $SESSION, $SITE;

        // Before we output any content, we need to ensure that certain

        // page components are set up.

        // Blocks must be set up early as they may require javascript which

        // has to be included in the page header before output is created.

        foreach ($this->page->blocks->get_regions() as $region) {

            $this->page->blocks->ensure_content_created($region, $this);

        }

        // Give plugins an opportunity to add any head elements. The callback

        // must always return a string containing valid html head content.

        $hook = new \core\hook\output\before_standard_head_html_generation($this);

        $hook->process_legacy_callbacks();

        di::get(hook_manager::class)->dispatch($hook);

        // Allow a url_rewrite plugin to setup any dynamic head content.

        if (isset($CFG->urlrewriteclass) && !isset($CFG->upgraderunning)) {

            $class = $CFG->urlrewriteclass;

            $hook->add_html($class::html_head_setup());

        }

        $hook->add_html('<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />' . "\n");

        $hook->add_html('<meta name="keywords" content="moodle, ' . $this->page->title . '" />' . "\n");

        // This is only set by the {@link redirect()} method

        $hook->add_html($this->metarefreshtag);

        // Check if a periodic refresh delay has been set and make sure we arn't

        // already meta refreshing

        if ($this->metarefreshtag=='' && $this->page->periodicrefreshdelay!==null) {

            $hook->add_html(

                html_writer::empty_tag('meta', [

                    'http-equiv' => 'refresh',

                    'content' => $this->page->periodicrefreshdelay . ';url='.$this->page->url->out(),

                ]),

            );

        }

        $output = $hook->get_output();

        // Set up help link popups for all links with the helptooltip class

        $this->page->requires->js_init_call('M.util.help_popups.setup');

        $focus = $this->page->focuscontrol;

        if (!empty($focus)) {

            if (preg_match("#forms\['([a-zA-Z0-9]+)'\].elements\['([a-zA-Z0-9]+)'\]#", $focus, $matches)) {

                // This is a horrifically bad way to handle focus but it is passed in

                // through messy formslib::moodleform

                $this->page->requires->js_function_call('old_onload_focus', array($matches[1], $matches[2]));

            } else if (strpos($focus, '.')!==false) {

                // Old style of focus, bad way to do it

                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);

                $this->page->requires->js_function_call('old_onload_focus', explode('.', $focus, 2));

            } else {

                // Focus element with given id

                $this->page->requires->js_function_call('focuscontrol', array($focus));

            }

        }

        // Get the theme stylesheet - this has to be always first CSS, this loads also styles.css from all plugins;

        // any other custom CSS can not be overridden via themes and is highly discouraged

        $urls = $this->page->theme->css_urls($this->page);

        foreach ($urls as $url) {

            $this->page->requires->css_theme($url);

        }

        // Get the theme javascript head and footer

        if ($jsurl = $this->page->theme->javascript_url(true)) {

            $this->page->requires->js($jsurl, true);

        }

        if ($jsurl = $this->page->theme->javascript_url(false)) {

            $this->page->requires->js($jsurl);

        }

        // Get any HTML from the page_requirements_manager.

        $output .= $this->page->requires->get_head_code($this->page, $this);

        // List alternate versions.

        foreach ($this->page->alternateversions as $type => $alt) {

            $output .= html_writer::empty_tag('link', array('rel' => 'alternate',

                    'type' => $type, 'title' => $alt->title, 'href' => $alt->url));

        }

        // Add noindex tag if relevant page and setting applied.

        $allowindexing = isset($CFG->allowindexing) ? $CFG->allowindexing : 0;

        $loginpages = array('login-index', 'login-signup');

        if ($allowindexing == 2 || ($allowindexing == 0 && in_array($this->page->pagetype, $loginpages))) {

            if (!isset($CFG->additionalhtmlhead)) {

                $CFG->additionalhtmlhead = '';

            }

            $CFG->additionalhtmlhead .= '<meta name="robots" content="noindex" />';

        }

        if (!empty($CFG->additionalhtmlhead)) {

            $output .= "\n".$CFG->additionalhtmlhead;

        }

        if ($this->page->pagelayout == 'frontpage') {

            $summary = s(strip_tags(format_text($SITE->summary, FORMAT_HTML)));

            if (!empty($summary)) {

                $output .= "<meta name=\"description\" content=\"$summary\" />\n";

            }

        }

        return $output;

    }

    /**

     * The standard tags (typically skip links) that should be output just inside

     * the start of the <body> tag. Designed to be called in theme layout.php files.

     *

     * @return string HTML fragment.

     */

    public function standard_top_of_body_html() {

        global $CFG;

        $output = $this->page->requires->get_top_of_body_code($this);

        if ($this->page->pagelayout !== 'embedded' && !empty($CFG->additionalhtmltopofbody)) {

            $output .= "\n".$CFG->additionalhtmltopofbody;

        }

        // Ensure that the callback exists prior to cache purge.

        // This is a critical page path.

        // TODO MDL-81134 Remove after LTS+1.

        require_once(__DIR__ . '/classes/hook/output/before_standard_top_of_body_html_generation.php');

        // Allow components to add content to the top of the body.

        $hook = new before_standard_top_of_body_html_generation($this, $output);

        $hook->process_legacy_callbacks();

        di::get(hook_manager::class)->dispatch($hook);

        $output = $hook->get_output();

        $output .= $this->maintenance_warning();

        return $output;

    }

    /**

     * Scheduled maintenance warning message.

     *

     * Note: This is a nasty hack to display maintenance notice, this should be moved

     *       to some general notification area once we have it.

     *

     * @return string

     */

    public function maintenance_warning() {

        global $CFG;

        $output = '';

        if (isset($CFG->maintenance_later) and $CFG->maintenance_later > time()) {

            $timeleft = $CFG->maintenance_later - time();

            // If timeleft less than 30 sec, set the class on block to error to highlight.

            $errorclass = ($timeleft < 30) ? 'alert-error alert-danger' : 'alert-warning';

            $output .= $this->box_start($errorclass . ' moodle-has-zindex maintenancewarning m-3 alert');

            $a = new stdClass();

            $a->hour = (int)($timeleft / 3600);

            $a->min = (int)(floor($timeleft / 60) % 60);

            $a->sec = (int)($timeleft % 60);

            if ($a->hour > 0) {

                $output .= get_string('maintenancemodeisscheduledlong', 'admin', $a);

            } else {

                $output .= get_string('maintenancemodeisscheduled', 'admin', $a);

            }

            $output .= $this->box_end();

            $this->page->requires->yui_module('moodle-core-maintenancemodetimer', 'M.core.maintenancemodetimer',

                    array(array('timeleftinsec' => $timeleft)));

            $this->page->requires->strings_for_js(

                    array('maintenancemodeisscheduled', 'maintenancemodeisscheduledlong', 'sitemaintenance'),

                    'admin');

        }

        return $output;

    }

    /**

     * content that should be output in the footer area

     * of the page. Designed to be called in theme layout.php files.

     *

     * @return string HTML fragment.

     */

    public function standard_footer_html() {

        if (during_initial_install()) {

            // Debugging info can not work before install is finished,

            // in any case we do not want any links during installation!

            return '';

        }

        // Ensure that the callback exists prior to cache purge.

        // This is a critical page path.

        // TODO MDL-81134 Remove after LTS+1.

        require_once(__DIR__ . '/classes/hook/output/before_standard_footer_html_generation.php');

        $hook = new before_standard_footer_html_generation($this);

        $hook->process_legacy_callbacks();

        di::get(hook_manager::class)->dispatch($hook);

        $output = $hook->get_output();

        if ($this->page->devicetypeinuse == 'legacy') {

            // The legacy theme is in use print the notification

            $output .= html_writer::tag('div', get_string('legacythemeinuse'), array('class'=>'legacythemeinuse'));

        }

        // Get links to switch device types (only shown for users not on a default device)

        $output .= $this->theme_switch_links();

        return $output;

    }

    /**

     * Performance information and validation links for debugging.

     *

     * @return string HTML fragment.

     */

    public function debug_footer_html() {

        global $CFG, $SCRIPT;

        $output = '';

        if (during_initial_install()) {

            // Debugging info can not work before install is finished.

            return $output;

        }

        // This function is normally called from a layout.php file

        // but some of the content won't be known until later, so we return a placeholder

        // for now. This will be replaced with the real content in the footer.

        $output .= $this->unique_performance_info_token;

        if (!empty($CFG->debugpageinfo)) {

            $output .= '<div class="performanceinfo pageinfo">' . get_string('pageinfodebugsummary', 'core_admin',

                $this->page->debug_summary()) . '</div>';

        }

        if (debugging(null, DEBUG_DEVELOPER) and has_capability('moodle/site:config', context_system::instance())) {  // Only in developer mode

            // Add link to profiling report if necessary

            if (function_exists('profiling_is_running') && profiling_is_running()) {

                $txt = get_string('profiledscript', 'admin');

                $title = get_string('profiledscriptview', 'admin');

                $url = $CFG->wwwroot . '/admin/tool/profiling/index.php?script=' . urlencode($SCRIPT);

                $link= '<a title="' . $title . '" href="' . $url . '">' . $txt . '</a>';

                $output .= '<div class="profilingfooter">' . $link . '</div>';

            }

            $purgeurl = new moodle_url('/admin/purgecaches.php', array('confirm' => 1,

                'sesskey' => sesskey(), 'returnurl' => $this->page->url->out_as_local_url(false)));

            $output .= '<div class="purgecaches">' .

                    html_writer::link($purgeurl, get_string('purgecaches', 'admin')) . '</div>';

            // Reactive module debug panel.

            $output .= $this->render_from_template('core/local/reactive/debugpanel', []);

        }

        if (!empty($CFG->debugvalidators)) {

            $siteurl = qualified_me();

            $nuurl = new moodle_url('https://validator.w3.org/nu/', ['doc' => $siteurl, 'showsource' => 'yes']);

            $waveurl = new moodle_url('https://wave.webaim.org/report#/' . urlencode($siteurl));

            $validatorlinks = [

                html_writer::link($nuurl, get_string('validatehtml')),

                html_writer::link($waveurl, get_string('wcagcheck'))

            ];

            $validatorlinkslist = html_writer::alist($validatorlinks, ['class' => 'list-unstyled ml-1']);

            $output .= html_writer::div($validatorlinkslist, 'validators');

        }

        return $output;

    }

    /**

     * Returns standard main content placeholder.

     * Designed to be called in theme layout.php files.

     *

     * @return string HTML fragment.

     */

    public function main_content() {

        // This is here because it is the only place we can inject the "main" role over the entire main content area

        // without requiring all theme's to manually do it, and without creating yet another thing people need to

        // remember in the theme.

        // This is an unfortunate hack. DO NO EVER add anything more here.

        // DO NOT add classes.

        // DO NOT add an id.

        return '<div role="main">'.$this->unique_main_content_token.'</div>';

    }

    /**

     * Returns information about an activity.

     *

     * @deprecated since Moodle 4.3 MDL-78744

     * @todo MDL-78926 This method will be deleted in Moodle 4.7

     * @param cm_info $cminfo The course module information.

     * @param cm_completion_details $completiondetails The completion details for this activity module.

     * @param array $activitydates The dates for this activity module.

     * @return string the activity information HTML.

     * @throws coding_exception

     */

    public function activity_information(cm_info $cminfo, cm_completion_details $completiondetails, array $activitydates): string {

        debugging('activity_information method is deprecated.', DEBUG_DEVELOPER);

        if (!$completiondetails->has_completion() && empty($activitydates)) {

            // No need to render the activity information when there's no completion info and activity dates to show.

            return '';

        }

        $activityinfo = new activity_information($cminfo, $completiondetails, $activitydates);

        $renderer = $this->page->get_renderer('core', 'course');

        return $renderer->render($activityinfo);