WebSVN – Moodle – Diff – /lib/pagelib.php

  * @property-read string $subpage The subpage identifier, if any.
  * @property-read theme_config $theme The theme for this page.
  * @property-read string $title The title that should go in the <head> section of the HTML of this page.
  * @property-read moodle_url $url The moodle url object for this page.
  */
-class moodle_page {
+class moodle_page
+{
     /** The state of the page before it has printed the header **/
     const STATE_BEFORE_HEADER = 0;
      * settings menu on an activity / resource page that is being displayed on a theme that
      * uses a settings menu.
+     *
      * @param bool $forced default of true, can be sent false to turn off the force.
      */
-    public function force_settings_menu($forced = true) {
+    public function force_settings_menu($forced = true)
+    {
         $this->_forcesettingsmenu = $forced;
+    }
     /**
      * Check to see if the settings menu is forced to display on this activity / resource page.
      * This only applies to themes that use the settings menu.
+     *
      * @return bool True if the settings menu is forced to display.
      */
+    public function is_settings_menu_forced()
     public function is_settings_menu_forced() {
         return $this->_forcesettingsmenu;
+    }
      * @return integer one of the STATE_XXX constants. You should not normally need
      * to use this in your code. It is intended for internal use by this class
      * and its friends like print_header, to check that everything is working as
      * expected. Also accessible as $PAGE->state.
      */
-    protected function magic_get_state() {
+    protected function magic_get_state()
+    {
         return $this->_state;
+    }
     /**
      * Please do not call this method directly, use the ->headerprinted syntax. {@link moodle_page::__get()}.
      * @return bool has the header already been printed?
      */
+    protected function magic_get_headerprinted()
     protected function magic_get_headerprinted() {
         return $this->_state >= self::STATE_IN_BODY;
+    }
     /**
      * Please do not call this method directly, use the ->course syntax. {@link moodle_page::__get()}.
      * @return stdClass the current course that we are inside - a row from the
      * course table. (Also available as $COURSE global.) If we are not inside
      * an actual course, this will be the site course.
+     */
-     */
+    protected function magic_get_course()
     protected function magic_get_course() {
         global $SITE;
         if (is_null($this->_course)) {
             return $SITE;
      * @return cm_info the course_module that this page belongs to. Will be null
      * if this page is not within a module. This is a full cm object, as loaded
      * by get_coursemodule_from_id or get_coursemodule_from_instance,
      * so the extra modname and name fields are present.
      */
-    protected function magic_get_cm() {
+    protected function magic_get_cm()
+    {
         return $this->_cm;
+    }
     /**
      * Please do not call this method directly, use the ->activityrecord syntax. {@link moodle_page::__get()}.
      * @return stdClass the row from the activities own database table (for example
      * the forum or quiz table) that this page belongs to. Will be null
      * if this page is not within a module.
      */
+    protected function magic_get_activityrecord()
     protected function magic_get_activityrecord() {
         if (is_null($this->_module) && !is_null($this->_cm)) {
             $this->load_activity_record();
+        }
         return $this->_module;
     /**
      * Please do not call this method directly, use the ->activityname syntax. {@link moodle_page::__get()}.
      * @return string the The type of activity we are in, for example 'forum' or 'quiz'.
      * Will be null if this page is not within a module.
      */
-    protected function magic_get_activityname() {
+    protected function magic_get_activityname()
+    {
         if (is_null($this->_cm)) {
             return null;
+        }
         return $this->_cm->modname;
+    }
     /**
      * Please do not call this method directly, use the ->category syntax. {@link moodle_page::__get()}.
      * @return stdClass|null the category that the page course belongs to. If there isn't one
      * (that is, if this is the front page course) returns null.
      */
-    protected function magic_get_category() {
+    protected function magic_get_category()
+    {
         $this->ensure_category_loaded();
         if (!empty($this->_categories)) {
             return reset($this->_categories);
         } else {
             return null;
      * @return array an array of all the categories the page course belongs to,
      * starting with the immediately containing category, and working out to
      * the top-level category. This may be the empty array if we are in the
      * front page course.
      */
-    protected function magic_get_categories() {
+    protected function magic_get_categories()
+    {
         $this->ensure_categories_loaded();
         return $this->_categories;
+    }
     /**
      * Please do not call this method directly, use the ->context syntax. {@link moodle_page::__get()}.
      * @return context the main context to which this page belongs.
      */
+    protected function magic_get_context()
     protected function magic_get_context() {
         global $CFG;
         if (is_null($this->_context)) {
             if (CLI_SCRIPT or NO_MOODLE_COOKIES) {
                 // Cli scripts work in system context, do not annoy devs with debug info.
                 // Very few scripts do not use cookies, we can safely use system as default context there.
             } else if (AJAX_SCRIPT && $CFG->debugdeveloper) {
                 // Throw exception inside AJAX script in developer mode, otherwise the debugging message may be missed.
                 throw new coding_exception('$PAGE->context was not set. You may have forgotten '
-                    .'to call require_login() or $PAGE->set_context()');
+                    . 'to call require_login() or $PAGE->set_context()');
             } else {
                 debugging('Coding problem: $PAGE->context was not set. You may have forgotten '
-                    .'to call require_login() or $PAGE->set_context(). The page may not display '
+                    . 'to call require_login() or $PAGE->set_context(). The page may not display '
-                    .'correctly as a result');
+                    . 'correctly as a result');
+            }
             $this->_context = context_system::instance();
+        }
         return $this->_context;
+    }
     /**
      * Please do not call this method directly, use the ->pagetype syntax. {@link moodle_page::__get()}.
      * @return string e.g. 'my-index' or 'mod-quiz-attempt'.
+     */
-     */
+    protected function magic_get_pagetype()
     protected function magic_get_pagetype() {
         global $CFG;
         if (is_null($this->_pagetype) || isset($CFG->pagepath)) {
             $this->initialise_default_pagetype();
     /**
      * Please do not call this method directly, use the ->pagetype syntax. {@link moodle_page::__get()}.
      * @return string The id to use on the body tag, uses {@link magic_get_pagetype()}.
      */
+    protected function magic_get_bodyid()
-    protected function magic_get_bodyid() {
+    {
-        return 'page-'.$this->pagetype;
+        return 'page-' . $this->pagetype;
+    }
     /**
      * Please do not call this method directly, use the ->pagelayout syntax. {@link moodle_page::__get()}.
      * @return string the general type of page this is. For example 'standard', 'popup', 'home'.
      *      Allows the theme to display things differently, if it wishes to.
+     */
-     */
+    protected function magic_get_pagelayout()
     protected function magic_get_pagelayout() {
         return $this->_pagelayout;
+    }
     /**
      * Please do not call this method directly, use the ->layout_options syntax. {@link moodle_page::__get()}.
+     * @return array returns arrays with options for layout file
-     * @return array returns arrays with options for layout file
+     */
-     */
+    protected function magic_get_layout_options()
     protected function magic_get_layout_options() {
         if (!is_array($this->_layout_options)) {
             $this->_layout_options = $this->theme->pagelayout_options($this->pagelayout);
+        }
         return $this->_layout_options;
+    }
     /**
+     * Please do not call this method directly, use the ->subpage syntax. {@link moodle_page::__get()}.
-     * Please do not call this method directly, use the ->subpage syntax. {@link moodle_page::__get()}.
+     * @return string The subpage identifier, if any.
-     * @return string The subpage identifier, if any.
+     */
-     */
+    protected function magic_get_subpage()
     protected function magic_get_subpage() {
         return $this->_subpage;
+    }
+    /**
-    /**
+     * Please do not call this method directly, use the ->bodyclasses syntax. {@link moodle_page::__get()}.
-     * Please do not call this method directly, use the ->bodyclasses syntax. {@link moodle_page::__get()}.
+     * @return string the class names to put on the body element in the HTML.
-     * @return string the class names to put on the body element in the HTML.
+     */
-     */
+    protected function magic_get_bodyclasses()
     protected function magic_get_bodyclasses() {
         return implode(' ', array_keys($this->_bodyclasses));
     }
     /**
-    /**
+     * Please do not call this method directly, use the ->title syntax. {@link moodle_page::__get()}.
-     * Please do not call this method directly, use the ->title syntax. {@link moodle_page::__get()}.
+     * @return string the title that should go in the <head> section of the HTML of this page.
-     * @return string the title that should go in the <head> section of the HTML of this page.
+     */
-     */
+    protected function magic_get_title()
     protected function magic_get_title() {
         return $this->_title;
+    }
     /**
-    /**
+     * Please do not call this method directly, use the ->heading syntax. {@link moodle_page::__get()}.
-     * Please do not call this method directly, use the ->heading syntax. {@link moodle_page::__get()}.
+     * @return string the main heading that should be displayed at the top of the <body>.
-     * @return string the main heading that should be displayed at the top of the <body>.
+     */
-     */
+    protected function magic_get_heading()
-    protected function magic_get_heading() {
+    {
+        return $this->_heading;
         return $this->_heading;
     /**
-    /**
+     * Please do not call this method directly, use the ->heading syntax. {@link moodle_page::__get()}.
-     * Please do not call this method directly, use the ->heading syntax. {@link moodle_page::__get()}.
+     * @return string The menu (or actions) to display in the heading
-     * @return string The menu (or actions) to display in the heading
+     */
-     */
+    protected function magic_get_headingmenu()
+    {
-    protected function magic_get_headingmenu() {
+        return $this->_headingmenu;
         return $this->_headingmenu;
     /**
-    /**
+     * Please do not call this method directly, use the ->docspath syntax. {@link moodle_page::__get()}.
     /**
      * Please do not call this method directly, use the ->url syntax. {@link moodle_page::__get()}.
      * @return moodle_url the clean URL required to load the current page. (You
      * should normally use this in preference to $ME or $FULLME.)
      */
-    protected function magic_get_url() {
+    protected function magic_get_url()
+    {
         global $FULLME;
         if (is_null($this->_url)) {
-            debugging('This page did not call $PAGE->set_url(...). Using '.s($FULLME), DEBUG_DEVELOPER);
+            debugging('This page did not call $PAGE->set_url(...). Using ' . s($FULLME), DEBUG_DEVELOPER);
             $this->_url = new moodle_url($FULLME);
             // Make sure the guessed URL cannot lead to dangerous redirects.
             $this->_url->remove_params('sesskey');
+        }
         return new moodle_url($this->_url); // Return a clone for safety.
     /**
      * The list of alternate versions of this page.
      * @return array mime type => object with ->url and ->title.
      */
+    protected function magic_get_alternateversions()
     protected function magic_get_alternateversions() {
         return $this->_alternateversions;
+    }
     /**
      * Please do not call this method directly, use the ->blocks syntax. {@link moodle_page::__get()}.
      * @return block_manager the blocks manager object for this page.
+     */
-     */
+    protected function magic_get_blocks()
     protected function magic_get_blocks() {
         global $CFG;
         if (is_null($this->_blocks)) {
             if (!empty($CFG->blockmanagerclass)) {
     /**
      * Please do not call this method directly, use the ->requires syntax. {@link moodle_page::__get()}.
      * @return page_requirements_manager tracks the JavaScript, CSS files, etc. required by this page.
      */
+    protected function magic_get_requires()
     protected function magic_get_requires() {
         if (is_null($this->_requires)) {
             $this->_requires = new page_requirements_manager();
+        }
         return $this->_requires;
+    }
     /**
      * Please do not call this method directly, use the ->cacheable syntax. {@link moodle_page::__get()}.
      * @return bool can this page be cached by the user's browser.
+     */
-     */
+    protected function magic_get_cacheable()
     protected function magic_get_cacheable() {
         return $this->_cacheable;
+    }
     /**
      * Please do not call this method directly, use the ->focuscontrol syntax. {@link moodle_page::__get()}.
+     * @return string the id of the HTML element to be focused when the page has loaded.
-     * @return string the id of the HTML element to be focused when the page has loaded.
+     */
-     */
+    protected function magic_get_focuscontrol()
     protected function magic_get_focuscontrol() {
         return $this->_focuscontrol;
+    }
     /**
+     * Please do not call this method directly, use the ->button syntax. {@link moodle_page::__get()}.
-     * Please do not call this method directly, use the ->button syntax. {@link moodle_page::__get()}.
+     * @return string the HTML to go where the Turn editing on button normally goes.
-     * @return string the HTML to go where the Turn editing on button normally goes.
+     */
-     */
+    protected function magic_get_button()
     protected function magic_get_button() {
         return $this->_button;
+    }
+    /**
-    /**
+     * Please do not call this method directly, use the ->theme syntax. {@link moodle_page::__get()}.
-     * Please do not call this method directly, use the ->theme syntax. {@link moodle_page::__get()}.
+     * @return theme_config the initialised theme for this page.
-     * @return theme_config the initialised theme for this page.
+     */
-     */
+    protected function magic_get_theme()
     protected function magic_get_theme() {
      * Returns an array of minipulations or false if there are none to make.
+     *
      * @since Moodle 2.5.1 2.6
      * @return bool|array
      */
-    protected function magic_get_blockmanipulations() {
+    protected function magic_get_blockmanipulations()
+    {
         if (!right_to_left()) {
             return false;
+        }
         if (is_null($this->_theme)) {
             $this->initialise_theme_and_output();
     /**
      * Please do not call this method directly, use the ->devicetypeinuse syntax. {@link moodle_page::__get()}.
      * @return string The device type being used.
      */
+    protected function magic_get_devicetypeinuse()
     protected function magic_get_devicetypeinuse() {
         if (empty($this->_devicetypeinuse)) {
             $this->_devicetypeinuse = core_useragent::get_user_device_type();
+        }
         return $this->_devicetypeinuse;
     /**
      * Please do not call this method directly use the ->periodicrefreshdelay syntax
      * {@link moodle_page::__get()}
      * @return int The periodic refresh delay to use with meta refresh
      */
-    protected function magic_get_periodicrefreshdelay() {
+    protected function magic_get_periodicrefreshdelay()
+    {
         return $this->_periodicrefreshdelay;
+    }
     /**
      * Please do not call this method directly use the ->opencontainers syntax. {@link moodle_page::__get()}
      * @return xhtml_container_stack tracks XHTML tags on this page that have been opened but not closed.
      *      mainly for internal use by the rendering code.
      */
+    protected function magic_get_opencontainers()
     protected function magic_get_opencontainers() {
         if (is_null($this->_opencontainers)) {
             $this->_opencontainers = new xhtml_container_stack();
+        }
         return $this->_opencontainers;
+    }
     /**
      * Return the navigation object
      * @return global_navigation
+     */
-     */
+    protected function magic_get_navigation()
     protected function magic_get_navigation() {
         if ($this->_navigation === null) {
             $this->_navigation = new global_navigation($this);
+        }
         return $this->_navigation;
+    }
     /**
      * Return a navbar object
+     * @return navbar
-     * @return navbar
+     */
-     */
+    protected function magic_get_navbar()
     protected function magic_get_navbar() {
         if ($this->_navbar === null) {
             $this->_navbar = new navbar($this);
+        }
         return $this->_navbar;
+    }
     /**
+     * Returns the settings navigation object
-     * Returns the settings navigation object
+     * @return settings_navigation
-     * @return settings_navigation
+     */
-     */
+    protected function magic_get_settingsnav()
     protected function magic_get_settingsnav() {
         if ($this->_settingsnav === null) {
     /**
      * Returns the flat navigation object
      * @return flat_navigation
      */
+    protected function magic_get_flatnav()
     protected function magic_get_flatnav() {
         if ($this->_flatnav === null) {
             $this->_flatnav = new flat_navigation($this);
             $this->_flatnav->initialise();
+        }
     /**
      * Returns the activity header object
      * @return activity_header
      */
+    protected function magic_get_activityheader(): activity_header
     protected function magic_get_activityheader(): activity_header {
         global $USER;
         if ($this->_activityheader === null) {
             $class = activity_header::class;
             // Try and load a custom class first.
     /**
      * Returns the secondary navigation object
+     *
      * @return secondary
      */
-    protected function magic_get_secondarynav() {
+    protected function magic_get_secondarynav()
+    {
         if ($this->_secondarynav === null) {
             $class = 'core\navigation\views\secondary';
             // Check whether activity defines its own secondary navigation.
     /**
      * Returns the primary navigation object
      * @return primary
      */
+    protected function magic_get_primarynav()
     protected function magic_get_primarynav() {
         if ($this->_primarynav === null) {
             $this->_primarynav = new primary($this);
             $this->_primarynav->initialise();
+        }
     /**
      * Returns the primary navigation object
      * @return primaryoutput
      */
+    protected function magic_get_primarynavcombined()
     protected function magic_get_primarynavcombined() {
         if ($this->_primarynavcombined === null) {
             $this->_primarynavcombined = new primaryoutput($this);
+        }
         return $this->_primarynavcombined;
     /**
      * Returns request IP address.
+     *
      * @return string IP address or null if unknown
      */
-    protected function magic_get_requestip() {
+    protected function magic_get_requestip()
+    {
         return getremoteaddr(null);
+    }
     /**
      * Returns the origin of current request.
+     *
      * Note: constants are not required because we need to use these values in logging and reports.
+     *
      * @return string 'web', 'ws', 'cli', 'restore', etc.
      */
+    protected function magic_get_requestorigin()
     protected function magic_get_requestorigin() {
         if (class_exists('restore_controller', false) && restore_controller::is_executing()) {
             return 'restore';
+        }
+     *
      * @param string $name property name
      * @return mixed
      * @throws coding_exception
      */
-    public function __get($name) {
+    public function __get($name)
+    {
         $getmethod = 'magic_get_' . $name;
         if (method_exists($this, $getmethod)) {
             return $this->$getmethod();
         } else {
             throw new coding_exception('Unknown property ' . $name . ' of $PAGE.');
      * @param string $name property name
      * @param mixed $value Value
      * @return void Throws exception if field not defined in page class
      * @throws coding_exception
      */
-    public function __set($name, $value) {
+    public function __set($name, $value)
+    {
         if (method_exists($this, 'set_' . $name)) {
             throw new coding_exception('Invalid attempt to modify page object', "Use \$PAGE->set_$name() instead.");
         } else {
             throw new coding_exception('Invalid attempt to modify page object', "Unknown property $name");
+        }
      * @param string $component name such as 'core', 'mod_forum' or 'qtype_multichoice'.
      * @param string $subtype optional subtype such as 'news' resulting to 'mod_forum_news'
      * @param string $target one of rendering target constants
      * @return renderer_base
      */
-    public function get_renderer($component, $subtype = null, $target = null) {
+    public function get_renderer($component, $subtype = null, $target = null)
+    {
         if ($this->pagelayout === 'maintenance') {
             // If the page is using the maintenance layout then we're going to force target to maintenance.
             // This leads to a special core renderer that is designed to block access to API's that are likely unavailable for this
             // page layout.
             $target = RENDERER_TARGET_MAINTENANCE;
     /**
      * Checks to see if there are any items on the navbar object
+     *
      * @return bool true if there are, false if not
      */
-    public function has_navbar() {
+    public function has_navbar()
+    {
         if ($this->_navbar === null) {
             $this->_navbar = new navbar($this);
+        }
         return $this->_navbar->has_items();
+    }
     /**
      * Switches from the regular requirements manager to the fragment requirements manager to
      * capture all necessary JavaScript to display a chunk of HTML such as an mform. This is for use
      * by the get_fragment() web service and not for use elsewhere.
      */
-    public function start_collecting_javascript_requirements() {
+    public function start_collecting_javascript_requirements()
+    {
         // Check that the requirements manager has not already been switched.
         if (get_class($this->_requires) == 'fragment_requirements_manager') {
             throw new coding_exception('JavaScript collection has already been started.');
+        }
         // The header needs to have been called to flush out the generic JavaScript for the page. This allows only
+    }
     /**
      * Switches back from collecting fragment JS requirement to the original requirement manager
      */
+    public function end_collecting_javascript_requirements()
     public function end_collecting_javascript_requirements() {
         if ($this->savedrequires === null) {
             throw new coding_exception('JavaScript collection has not been started.');
+        }
         $this->_requires = $this->savedrequires;
      * Should the current user see this page in editing mode.
      * That is, are they allowed to edit this page, and are they currently in
      * editing mode.
      * @return bool
      */
-    public function user_is_editing() {
+    public function user_is_editing()
+    {
         global $USER;
         return !empty($USER->editing) && $this->user_allowed_editing();
+    }
     /**
      * Does the user have permission to edit blocks on this page.
      * Can be forced to false by calling the force_lock_all_blocks() method.
+     *
      * @return bool
      */
+    public function user_can_edit_blocks()
     public function user_can_edit_blocks() {
         return $this->_forcelockallblocks ? false : has_capability($this->_blockseditingcap, $this->_context);
+    }
     /**
      * Does the user have permission to see this page in editing mode.
      * @return bool
+     */
-     */
+    public function user_allowed_editing()
     public function user_allowed_editing() {
         return has_any_capability($this->all_editing_caps(), $this->_context);
+    }
     /**
      * Get a description of this page. Normally displayed in the footer in developer debug mode.
+     * @return string
-     * @return string
+     */
-     */
+    public function debug_summary()
     public function debug_summary() {
         $summary = '';
         $summary .= 'General type: ' . $this->pagelayout . '. ';
      * The state must be one of that STATE_... constants, and the state is only allowed to advance one step at a time.
+     *
      * @param int $state The new state.
      * @throws coding_exception
      */
-    public function set_state($state) {
+    public function set_state($state)
+    {
         if ($state != $this->_state + 1 || $state > self::STATE_DONE) {
             throw new coding_exception('Invalid state passed to moodle_page::set_state. We are in state ' .
-                    $this->_state . ' and state ' . $state . ' was requested.');
+                $this->_state . ' and state ' . $state . ' was requested.');
+        }
         if ($state == self::STATE_PRINTING_HEADER) {
             $this->starting_output();
      * Sets $PAGE->context to the course context, if it is not already set.
+     *
      * @param stdClass $course the course to set as the global course.
      * @throws coding_exception
      */
-    public function set_course($course) {
+    public function set_course($course)
+    {
         global $COURSE, $PAGE, $CFG, $SITE;
         if (empty($course->id)) {
             throw new coding_exception('$course passed to moodle_page::set_course does not look like a proper course object.');
         if (!empty($this->_course->id) && $this->_course->id != $course->id) {
             $this->_categories = null;
         }
-        $this->_course = clone($course);
+        $this->_course = clone ($course);
         if ($this === $PAGE) {
             $this->set_context(context_course::instance($this->_course->id));
+        }
         // Notify course format that this page is set for the course.
         if ($this->_course->id != $SITE->id) {
-            require_once($CFG->dirroot.'/course/lib.php');
+            require_once($CFG->dirroot . '/course/lib.php');
             $courseformat = course_get_format($this->_course);
-            $this->add_body_class('format-'. $courseformat->get_format());
+            $this->add_body_class('format-' . $courseformat->get_format());
             $courseformat->page_set_course($this);
         } else {
             $this->add_body_class('format-site');
+        }
     /**
      * Set the main context to which this page belongs.
+     *
      * @param ?context $context a context object. You normally get this with context_xxxx::instance().
      */
-    public function set_context($context) {
+    public function set_context($context)
+    {
         if ($context === null) {
             // Extremely ugly hack which sets context to some value in order to prevent warnings,
             // use only for core error handling!!!!
             if (!$this->_context) {
                 $this->_context = context_system::instance();
         // Ideally we should set context only once.
         if (isset($this->_context) && $context->id !== $this->_context->id) {
             $current = $this->_context->contextlevel;
             if ($current == CONTEXT_SYSTEM or $current == CONTEXT_COURSE) {
                 // Hmm - not ideal, but it might produce too many warnings due to the design of require_login.
+            } else if (
-            } else if ($current == CONTEXT_MODULE and ($parentcontext = $context->get_parent_context()) and
+                $current == CONTEXT_MODULE and ($parentcontext = $context->get_parent_context()) and
-                $this->_context->id == $parentcontext->id) {
+                $this->_context->id == $parentcontext->id
+            ) {
                 // Hmm - most probably somebody did require_login() and after that set the block context.
             } else {
                 // We do not want devs to do weird switching of context levels on the fly because we might have used
                 // the context already such as in text filter in page title.
                 debugging("Coding problem: unsupported modification of PAGE->context from {$current} to {$context->contextlevel}");
      * @param stdClass $course
      * @param stdClass $module
      * @return void
      * @throws coding_exception
      */
-    public function set_cm($cm, $course = null, $module = null) {
+    public function set_cm($cm, $course = null, $module = null)
+    {
         global $DB, $CFG, $SITE;
         if (!isset($cm->id) || !isset($cm->course)) {
             throw new coding_exception('Invalid $cm. It has to be instance of cm_info or record from the course_modules table.');
             $this->set_activity_record($module);
+        }
         // Notify course format that this page is set for the course module.
         if ($this->_course->id != $SITE->id) {
-            require_once($CFG->dirroot.'/course/lib.php');
+            require_once($CFG->dirroot . '/course/lib.php');
             course_get_format($this->_course)->page_set_cm($this);
+        }
+    }
      * from the forum table.
+     *
      * @param stdClass $module A row from the main database table for the module that this page belongs to.
      * @throws coding_exception
      */
-    public function set_activity_record($module) {
+    public function set_activity_record($module)
+    {
         if (is_null($this->_cm)) {
             throw new coding_exception('You cannot call $PAGE->set_activity_record until after $PAGE->cm has been set.');
+        }
         if ($module->id != $this->_cm->instance || $module->course != $this->_course->id) {
             throw new coding_exception('The activity record does not seem to correspond to the cm that has been set.');
      * for example 'course-view-weeks'. This gets used as the id attribute on
      * <body> and also for determining which blocks are displayed.
+     *
      * @param string $pagetype e.g. 'my-index' or 'mod-quiz-attempt'.
      */
-    public function set_pagetype($pagetype) {
+    public function set_pagetype($pagetype)
+    {
         $this->_pagetype = $pagetype;
+    }
     /**
      * The only place to find an accurate up-to-date list of the page layouts
      * available for your version of Moodle is {@link theme/base/config.php}
+     *
      * @param string $pagelayout the page layout this is. For example 'popup', 'home'.
      */
-    public function set_pagelayout($pagelayout) {
+    public function set_pagelayout($pagelayout)
+    {
         global $SESSION;
         if (!empty($SESSION->forcepagelayout)) {
             $this->_pagelayout = $SESSION->forcepagelayout;
      * then you can set a subpage id as well. For example, the tags page sets
+     *
      * @param string $subpage an arbitrary identifier that, along with context->id
      *      and pagetype, uniquely identifies this page.
      */
-    public function set_subpage($subpage) {
+    public function set_subpage($subpage)
+    {
         if (empty($subpage)) {
             $this->_subpage = '';
         } else {
             $this->_subpage = $subpage;
+        }
     /**
      * Force set secondary_nav. Useful in cases where we dealing with non course modules. e.g. blocks, tools.
      * @param secondary $nav
      */
+    public function set_secondarynav(secondary $nav)
     public function set_secondarynav(secondary $nav) {
         $this->_secondarynav = $nav;
+    }
     /**
      * Adds a CSS class to the body tag of the page.
+     *
      * @param string $class add this class name ot the class attribute on the body tag.
      * @throws coding_exception
+     */
-     */
+    public function add_body_class($class)
     public function add_body_class($class) {
         if ($this->_state > self::STATE_BEFORE_HEADER) {
             throw new coding_exception('Cannot call moodle_page::add_body_class after output has been started.');
+        }
     /**
      * Adds an array of body classes to the body tag of this page.
+     *
      * @param array $classes this utility method calls add_body_class for each array element.
      */
-    public function add_body_classes($classes) {
+    public function add_body_classes($classes)
+    {
         foreach ($classes as $class) {
             $this->add_body_class($class);
+        }
+    }
      * @param string $title the title that should go in the <head> section of the HTML of this page.
      * @param bool $appendsitename Appends site name at the end of the given title. It is encouraged to append the site name as this
      *                              especially helps with accessibility. If it's necessary to override this, please keep in mind
      *                              to ensure that the title provides a concise summary of the page being displayed.
      */
-    public function set_title($title, bool $appendsitename = true) {
+    public function set_title($title, bool $appendsitename = true)
+    {
         global $CFG;
         $title = format_string($title);
         $title = strip_tags($title);
+     *
      * @param string $heading the main heading that should be displayed at the top of the <body>.
      * @param bool $applyformatting apply format_string() - by default true.
      * @param bool $clean whether the heading should be cleaned or not when no formatting is applied - by default true.
      */
-    public function set_heading($heading, bool $applyformatting = true, bool $clean = true) {
+    public function set_heading($heading, bool $applyformatting = true, bool $clean = true)
+    {
         $this->_heading = $applyformatting ? format_string($heading) : ($clean ? clean_text($heading) : $heading);
+    }
     /**
      * Sets some HTML to use next to the heading {@link moodle_page::set_heading()}
+     *
      * @param string $menu The menu/content to show in the heading
      */
+    public function set_headingmenu($menu)
     public function set_headingmenu($menu) {
         $this->_headingmenu = $menu;
+    }
      * automatically sets the page context to the category context.
+     *
      * @param int $categoryid The id of the category to set.
      * @throws coding_exception
      */
-    public function set_category_by_id($categoryid) {
+    public function set_category_by_id($categoryid)
+    {
         global $SITE;
         if (!is_null($this->_course)) {
             throw new coding_exception('Course has already been set. You cannot change the category now.');
+        }
         if (is_array($this->_categories)) {
      * script name. So, for example, for mod/quiz/attempt.php, pagetype is
      * mod-quiz-attempt, and so docspath is mod/quiz/attempt.
+     *
      * @param string $path the path to use at the end of the moodle docs URL.
      */
-    public function set_docs_path($path) {
+    public function set_docs_path($path)
+    {
         $this->_docspath = $path;
+    }
     /**
+     *
      * @param moodle_url|string $url URL relative to $CFG->wwwroot or {@link moodle_url} instance
      * @param array $params parameters to add to the URL
      * @throws coding_exception
      */
-    public function set_url($url, ?array $params = null) {
+    public function set_url($url, ?array $params = null)
+    {
         global $CFG;
         if (is_string($url) && strpos($url, 'http') !== 0) {
             if (strpos($url, '/') === 0) {
      * before doing any redirect.
+     *
      * @param string $param the name of the parameter to make sure is not in the
      * page URL.
      */
-    public function ensure_param_not_in_url($param) {
+    public function ensure_param_not_in_url($param)
+    {
         $this->_url->remove_params($param);
+    }
     /**
      * @param string $title The title to give the alternate version.
      * @param string|moodle_url $url The URL of the alternate version.
      * @param string $mimetype The mime-type of the alternate version.
      * @throws coding_exception
      */
-    public function add_alternate_version($title, $url, $mimetype) {
+    public function add_alternate_version($title, $url, $mimetype)
+    {
         if ($this->_state > self::STATE_BEFORE_HEADER) {
             throw new coding_exception('Cannot call moodle_page::add_alternate_version after output has been started.');
+        }
         $alt = new stdClass;
         $alt->title = $title;
     /**
      * Specify a form control should be focused when the page has loaded.
+     *
      * @param string $controlid the id of the HTML element to be focused.
      */
-    public function set_focuscontrol($controlid) {
+    public function set_focuscontrol($controlid)
+    {
         $this->_focuscontrol = $controlid;
+    }
     /**
      * Specify a fragment of HTML that goes where the 'Turn editing on' button normally goes.
+     *
      * @param string $html the HTML to display there.
      */
+    public function set_button($html)
     public function set_button($html) {
         $this->_button = $html;
+    }
      * pages like the My Moodle page need to use a different capability
      * like 'moodle/my:manageblocks'.
+     *
      * @param string $capability a capability.
      */
-    public function set_blocks_editing_capability($capability) {
+    public function set_blocks_editing_capability($capability)
+    {
         $this->_blockseditingcap = $capability;
+    }
     /**
      * Some pages let you turn editing on for reasons other than editing blocks.
      * If that is the case, you can pass other capabilities that let the user
      * edit this page here.
+     *
      * @param string|array $capability either a capability, or an array of capabilities.
      */
+    public function set_other_editing_capability($capability)
     public function set_other_editing_capability($capability) {
         if (is_array($capability)) {
             $this->_othereditingcaps = array_unique($this->_othereditingcaps + $capability);
         } else {
             $this->_othereditingcaps[] = $capability;
     /**
      * Sets whether the browser should cache this page or not.
+     *
      * @param bool $cacheable can this page be cached by the user's browser.
      */
-    public function set_cacheable($cacheable) {
+    public function set_cacheable($cacheable)
+    {
         $this->_cacheable = $cacheable;
+    }
     /**
      * a coding exception will be thrown.
+     *
      * @param int $delay Sets the delay before refreshing the page, if set to null refresh is cancelled.
      * @throws coding_exception
      */
-    public function set_periodic_refresh_delay($delay = null) {
+    public function set_periodic_refresh_delay($delay = null)
+    {
         if ($this->_state > self::STATE_BEFORE_HEADER) {
             throw new coding_exception('You cannot set a periodic refresh delay after the header has been printed');
+        }
         if ($delay === null) {
             $this->_periodicrefreshdelay = null;
      * Please use this cautiously.
      * It is only intended to be used by the themes selector admin page.
+     *
      * @param string $themename the name of the theme to use.
      */
-    public function force_theme($themename) {
+    public function force_theme($themename)
+    {
         $this->ensure_theme_not_set();
         $this->_theme = theme_config::load($themename);
+    }
     /**
      * Reload theme settings.
+     *
      * This is used when we need to reset settings
      * because they are now double cached in theme.
      */
+    public function reload_theme()
     public function reload_theme() {
         if (!is_null($this->_theme)) {
             $this->_theme = theme_config::load($this->_theme->name);
+        }
      * This overrides any capabilities and is intended only for pages where no user (including admins) should be able to
      * modify blocks on the page (eg My Courses).
+     *
      * @return void
      */
-    public function force_lock_all_blocks(): void {
+    public function force_lock_all_blocks(): void
+    {
         $this->_forcelockallblocks = true;
+    }
     /**
      * as an argument to web services in AJAX requests and retrieve all data associated with
      * the page without actually executing PHP code on that page.
+     *
      * @return string|null
      */
-    public function get_edited_page_hash(): ?string {
+    public function get_edited_page_hash(): ?string
+    {
         global $SESSION;
         if (!$this->user_is_editing()) {
             return null;
+        }
         // Check if session is still active to prevent mutation after close
+        // If we're in shutdown phase or session was already closed, don't modify session
+        if (
+            defined('ABORT_AFTER_CONFIG') || !session_id() || session_status() !== PHP_SESSION_ACTIVE ||
-        if (!\core\session\manager::session_exists(session_id()) || !\core\session\manager::is_session_active()) {
+            !\core\session\manager::is_session_active()
+        ) {
             return null;
+        }
         $url = new moodle_url($this->url);
         $url->set_anchor(null);
         $data = [
             'contextid' => $this->context->id,
             'url' => $url->out_as_local_url(false),
+     *
      * @param string $hash
      * @param int $strictness
      * @return self|null
      */
-    public static function retrieve_edited_page(string $hash, $strictness = IGNORE_MISSING): ?self {
+    public static function retrieve_edited_page(string $hash, $strictness = IGNORE_MISSING): ?self
+    {
         global $CFG, $SESSION;
         $data = $SESSION->editedpages[$hash] ?? null;
+        if (
-        if (!$data || !is_array($data)
+            !$data || !is_array($data)
-                || $hash !== md5(json_encode($data + ['sesskey' => sesskey()]))) {
+            || $hash !== md5(json_encode($data + ['sesskey' => sesskey()]))
+        ) {
             // This can happen if the session cache becomes corrupt or the user logged out and back
             // in in another window and changed their session. Refreshing the page will generate
             // and store the correct page hash.
             if ($strictness === MUST_EXIST) {
                 throw new moodle_exception('editedpagenotfound');
     /**
      * This method is called when the page first moves out of the STATE_BEFORE_HEADER
      * state. This is our last change to initialise things.
      */
+    protected function starting_output()
     protected function starting_output() {
         global $CFG;
         if (!during_initial_install()) {
+        }
         // If maintenance mode is on, change the page header.
         if (!empty($CFG->maintenance_enabled)) {
             $this->set_button('<a href="' . $CFG->wwwroot . '/' . $CFG->admin .
-                    '/settings.php?section=maintenancemode">' . get_string('maintenancemode', 'admin') .
+                '/settings.php?section=maintenancemode">' . get_string('maintenancemode', 'admin') .
-                    '</a> ' . $this->button);
+                '</a> ' . $this->button);
             $this->set_title(get_string('maintenancemode', 'admin'));
      * blocks_manager about the theme block regions, and then, if
      * we are $PAGE, set up the global $OUTPUT.
+     *
      * @return void
      */
-    public function initialise_theme_and_output() {
+    public function initialise_theme_and_output()
+    {
         global $OUTPUT, $PAGE, $SITE, $CFG;
         if (!empty($this->_wherethemewasinitialised)) {
             return;
     /**
      * For diagnostic/debugging purposes, find where the theme setup was triggered.
+     *
      * @return null|array null if theme not yet setup. Stacktrace if it was.
      */
-    public function get_where_theme_was_initialised() {
+    public function get_where_theme_was_initialised()
+    {
         return $this->_wherethemewasinitialised;
+    }
     /**
      * Reset the theme and output for a new context. This only makes sense from
      * external::validate_context(). Do not cheat.
      */
+    public function reset_theme_and_output()
     public function reset_theme_and_output() {
         global $COURSE, $SITE;
-        $COURSE = clone($SITE);
+        $COURSE = clone ($SITE);
         $this->_theme = null;
         $this->_wherethemewasinitialised = null;
         $this->_course = null;
+     *
      * This depends on numerous $CFG settings, and the properties of this page.
+     *
      * @return string the name of the theme that should be used on this page.
      */
-    protected function resolve_theme() {
+    protected function resolve_theme()
+    {
         global $CFG, $USER, $SESSION;
         if (empty($CFG->themeorder)) {
             $themeorder = array('course', 'category', 'session', 'user', 'cohort', 'site');
+        }
         $mnetpeertheme = '';
         $mnetvarsok = isset($CFG->mnet_localhost_id) && isset($USER->mnethostid);
         if (isloggedin() and $mnetvarsok and $USER->mnethostid != $CFG->mnet_localhost_id) {
-            require_once($CFG->dirroot.'/mnet/peer.php');
+            require_once($CFG->dirroot . '/mnet/peer.php');
             $mnetpeer = new mnet_peer();
             $mnetpeer->set_id($USER->mnethostid);
             if ($mnetpeer->force_theme == 1 && $mnetpeer->theme != '') {
                 $mnetpeertheme = $mnetpeer->theme;
             switch ($themetype) {
                 case 'course':
                     if (!empty($CFG->allowcoursethemes) && !empty($this->_course->theme)) {
                         return $this->_course->theme;
+                    }
-                break;
+                    break;
                 case 'category':
                     if (!empty($CFG->allowcategorythemes) && !empty($this->_course)) {
                         $categories = $this->categories;
                         foreach ($categories as $category) {
                             if (!empty($category->theme)) {
                                 return $category->theme;
+                            }
+                        }
                     }
-                break;
+                    break;
                 case 'session':
                     if (!empty($SESSION->theme)) {
                         return $SESSION->theme;
+                    }
-                break;
+                    break;
                 case 'user':
                     if (!empty($CFG->allowuserthemes) && !empty($USER->theme)) {
                         if ($mnetpeertheme) {
                             return $mnetpeertheme;
                         } else {
                             return $USER->theme;
+                        }
+                    }
-                break;
+                    break;
                 case 'cohort':
                     if (!empty($CFG->allowcohortthemes) && !empty($USER->cohorttheme)) {
                         return $USER->cohorttheme;
+                    }
-                break;
+                    break;
      * @param string $script the path to the script that should be used to
      * initialise ->pagetype. If not passed the $SCRIPT global will be used.
      * If legacy code has set $CFG->pagepath that will be used instead, and a
      * developer warning issued.
      */
-    protected function initialise_default_pagetype($script = null) {
+    protected function initialise_default_pagetype($script = null)
+    {
         global $CFG, $SCRIPT;
         if (isset($CFG->pagepath)) {
             debugging('Some code appears to have set $CFG->pagepath. That was a horrible deprecated thing. ' .
-                    'Don\'t do it! Try calling $PAGE->set_pagetype() instead.');
+                'Don\'t do it! Try calling $PAGE->set_pagetype() instead.');
             $script = $CFG->pagepath;
             unset($CFG->pagepath);
+        }
      *    - Language direction
      *    - YUI CSS initialisation
      *    - Pagelayout
      * These are commonly used in CSS to target specific types of pages.
      */
-    protected function initialise_standard_body_classes() {
+    protected function initialise_standard_body_classes()
+    {
         global $CFG, $USER;
         $pagetype = $this->pagetype;
         if ($pagetype == 'site-index') {
      * This will load {@link moodle_page::$_module} with a row from the related
      * module table in the database.
      * For instance if {@link moodle_page::$_cm} is a forum then a row from the
      * forum table will be loaded.
      */
-    protected function load_activity_record() {
+    protected function load_activity_record()
+    {
         global $DB;
         if (is_null($this->_cm)) {
             return;
+        }
         $this->_module = $DB->get_record($this->_cm->modname, array('id' => $this->_cm->instance));
      * loaded, and if not, the function loads it now.
+     *
      * @return void
      * @throws coding_exception
      */
-    protected function ensure_category_loaded() {
+    protected function ensure_category_loaded()
+    {
         if (is_array($this->_categories)) {
             return; // Already done.
+        }
         if (is_null($this->_course)) {
             throw new coding_exception('Attempt to get the course category for this page before the course was set.');
      * Loads the requested category into the pages categories array.
+     *
      * @param int $categoryid
      * @throws moodle_exception
      */
-    protected function load_category($categoryid) {
+    protected function load_category($categoryid)
+    {
         global $DB;
         $category = $DB->get_record('course_categories', array('id' => $categoryid));
         if (!$category) {
             throw new moodle_exception('unknowncategory', a: $categoryid);
+        }
      * Ensures that the category the current course is within, as well as all of
      * its parent categories, have been loaded.
+     *
      * @return void
      */
-    protected function ensure_categories_loaded() {
+    protected function ensure_categories_loaded()
+    {
         global $DB;
         $this->ensure_category_loaded();
         if (!is_null(end($this->_categories))) {
             return; // Already done.
+        }
     /**
      * Ensure the theme has not been loaded yet. If it has an exception is thrown.
+     *
      * @throws coding_exception
      */
-    protected function ensure_theme_not_set() {
+    protected function ensure_theme_not_set()
+    {
         // This is explicitly allowed for webservices though which may process many course contexts in a single request.
         if (WS_SERVER) {
             return;
+        }
+        if (!is_null($this->_theme)) {
-        if (!is_null($this->_theme)) {
+            throw new coding_exception(
-            throw new coding_exception('The theme has already been set up for this page ready for output. ' .
+                'The theme has already been set up for this page ready for output. ' .
                     'Therefore, you can no longer change the theme, or anything that might affect what ' .
                     'the current theme is, for example, the course.',
+                'Stack trace when the theme was set up: ' . format_backtrace($this->_wherethemewasinitialised)
-                    'Stack trace when the theme was set up: ' . format_backtrace($this->_wherethemewasinitialised));
+            );
+        }
+    }
     /**
      * Converts the provided URL into a CSS class that be used within the page.
      * This is primarily used to add the wwwroot to the body tag as a CSS class.
+     *
      * @param string $url
      * @return string
+     */
-     */
+    protected function url_to_class_name($url)
     protected function url_to_class_name($url) {
         $bits = parse_url($url);
         $class = str_replace('.', '-', $bits['host']);
         if (!empty($bits['port'])) {
      * Combines all of the required editing caps for the page and returns them
      * as an array.
+     *
      * @return array
      */
-    protected function all_editing_caps() {
+    protected function all_editing_caps()
+    {
         $caps = $this->_othereditingcaps;
         $caps[] = $this->_blockseditingcap;
         return $caps;
+    }
     /**
      * Returns true if the page URL has beem set.
+     *
      * @return bool
      */
+    public function has_set_url()
-    public function has_set_url() {
+    {
-        return ($this->_url!==null);
+        return ($this->_url !== null);
+    }
     /**
      * Gets set when the block actions for the page have been processed.
+     *
      * @param bool $setting
+     */
-     */
+    public function set_block_actions_done($setting = true)
     public function set_block_actions_done($setting = true) {
         $this->_block_actions_done = $setting;
+    }
     /**
      * Are popup notifications allowed on this page?
      * Popup notifications may be disallowed in situations such as while upgrading or completing a quiz
      *
+     * @return bool true if popup notifications may be displayed
-     * @return bool true if popup notifications may be displayed
+     */
-     */
+    public function get_popup_notification_allowed()
     public function get_popup_notification_allowed() {
         return $this->_popup_notification_allowed;
+    }
     /**
      * Allow or disallow popup notifications on this page. Popups are allowed by default.
+     *
      * @param bool $allowed true if notifications are allowed. False if not allowed. They are allowed by default.
-     * @param bool $allowed true if notifications are allowed. False if not allowed. They are allowed by default.
+     */
-     */
+    public function set_popup_notification_allowed($allowed)
     public function set_popup_notification_allowed($allowed) {
         $this->_popup_notification_allowed = $allowed;
+    }
     /**
      * Returns the block region having made any required theme manipulations.
      *
+     * @since Moodle 2.5.1 2.6
-     * @since Moodle 2.5.1 2.6
+     * @param string $region
-     * @param string $region
+     * @return string
-     * @return string
+     */
-     */
+    public function apply_theme_region_manipulations($region)
     public function apply_theme_region_manipulations($region) {
      * Add a report node and a specific report to the navigation.
+     *
      * @param int $userid The user ID that we are looking to add this report node to.
      * @param array $nodeinfo Name and url of the final node that we are creating.
      */
-    public function add_report_nodes($userid, $nodeinfo) {
+    public function add_report_nodes($userid, $nodeinfo)
+    {
         global $USER;
         // Try to find the specific user node.
         $newusernode = $this->navigation->find('user' . $userid, null);
         $reportnode = null;
         $navigationnodeerror =
-                'Could not find the navigation node requested. Please check that the node you are looking for exists.';
+            'Could not find the navigation node requested. Please check that the node you are looking for exists.';
         if ($userid != $USER->id  || $this->context->contextlevel == CONTEXT_COURSE) {
             // Within a course context we need to properly indicate how we have come to the page,
             // regardless of whether it's currently logged in user or not.
             // Check that we have a valid node.
             if (empty($newusernode)) {
+            }
             // Add 'Reports' to our node.
             $reportnode = $myprofilenode->add(get_string('reports'));
+        }
         // Finally add the report to the navigation tree.
+        $reportnode->add(
+            $nodeinfo['name'],
+            $nodeinfo['url'],
-        $reportnode->add($nodeinfo['name'], $nodeinfo['url'], navigation_node::TYPE_CUSTOM, null, null,
+            navigation_node::TYPE_CUSTOM,
+            null,
+            null,
-            new pix_icon('i/report', $nodeinfo['name']));
+            new pix_icon('i/report', $nodeinfo['name'])
+        );
+    }
     /**
      * Add some HTML to the list of actions to render in the header actions menu.
+     *
      * @param string $html The HTML to add.
      */
+    public function add_header_action(string $html): void
     public function add_header_action(string $html): void {
         $this->_headeractions[] = $html;
+    }
     /**
      * Get the list of HTML for actions to render in the header actions menu.
+     *
      * @return string[]
+     */
-     */
+    public function get_header_actions(): array
     public function get_header_actions(): array {
         return $this->_headeractions;
+    }
     /**
      * Set the flag to indicate if the region main settings should be rendered as an action
      * in the header actions menu rather than at the top of the content.
      *
+     * @param bool $value If the settings should be in the header.
-     * @param bool $value If the settings should be in the header.
+     */
-     */
+    public function set_include_region_main_settings_in_header_actions(bool $value): void
     public function set_include_region_main_settings_in_header_actions(bool $value): void {
         $this->_regionmainsettingsinheader = $value;
+    }
     /**
      * Check if the  region main settings should be rendered as an action in the header actions
      * menu rather than at the top of the content.
+     *
      * @return bool
-     * @return bool
+     */
-     */
+    public function include_region_main_settings_in_header_actions(): bool
     public function include_region_main_settings_in_header_actions(): bool {
         return $this->_regionmainsettingsinheader;
+    }
     /**
      * Set the flag to indicate if the secondary navigation should be rendered.
      *
+     * @param bool $hassecondarynavigation If the secondary navigation should be rendered.
-     * @param bool $hassecondarynavigation If the secondary navigation should be rendered.
+     * @param bool $istablist When true, the navigation bar should be rendered and behave with a tablist ARIA role.
-     * @param bool $istablist When true, the navigation bar should be rendered and behave with a tablist ARIA role.
+     *                        If false, it's rendered with a menubar ARIA role. Defaults to false.
-     *                        If false, it's rendered with a menubar ARIA role. Defaults to false.
+     */
-     */
+    public function set_secondary_navigation(bool $hassecondarynavigation, bool $istablist = false): void
     public function set_secondary_navigation(bool $hassecondarynavigation, bool $istablist = false): void {
         $this->_hassecondarynavigation = $hassecondarynavigation;
         $this->_hastablistsecondarynavigation = $istablist;
+    }
+    /**
-    /**
+     * Check if the secondary navigation should be rendered.
      * Check if the secondary navigation should be rendered.
      * @return bool
-     * @return bool
+     */
-     */
+    public function has_secondary_navigation(): bool
     public function has_secondary_navigation(): bool {
         return $this->_hassecondarynavigation;
     }
     /**
-    /**
+     * Check if the secondary navigation should be rendered with a tablist as opposed to a menubar.
      * Check if the secondary navigation should be rendered with a tablist as opposed to a menubar.
      * @return bool
-     * @return bool
+     */
-     */
+    public function has_tablist_secondary_navigation(): bool
     public function has_tablist_secondary_navigation(): bool {
         return $this->_hastablistsecondarynavigation;
+    }
     /**
-    /**
+     * Set the key of the secondary nav node to be activated.
      * Set the key of the secondary nav node to be activated.
      * @param string $navkey the key of the secondary nav node to be activated.
-     * @param string $navkey the key of the secondary nav node to be activated.
+     */
-     */
+    public function set_secondary_active_tab(string $navkey): void
-    public function set_secondary_active_tab(string $navkey): void {
+    {
+        $this->_activekeysecondary = $navkey;
         $this->_activekeysecondary = $navkey;
     /**
-    /**
+     * The key of secondary nav node to activate.
      * The key of secondary nav node to activate.
      * @return string|null get the key of the secondary node to activate.
-     * @return string|null get the key of the secondary node to activate.
+     */
-     */
+    public function get_secondary_active_tab(): ?string
+    {
-    public function get_secondary_active_tab(): ?string {
+        return $this->_activekeysecondary;
         return $this->_activekeysecondary;
     /**
-    /**
+     * Set the key of the primary nav node to be activated.
      * Set the key of the primary nav node to be activated.
      * @param string $navkey
-     * @param string $navkey
+     */
+    public function set_primary_active_tab(string $navkey): void
      */
-    public function set_primary_active_tab(string $navkey): void {
+        $this->_activenodeprimary = $navkey;
         $this->_activenodeprimary = $navkey;
     /**
-    /**
+     * The key of the primary nav node to activate.
      * The key of the primary nav node to activate.
      * @return string|null get the key of the primary nav node to activate.
-     * @return string|null get the key of the primary nav node to activate.
+     */
+    public function get_primary_activate_tab(): ?string
      */
-    public function get_primary_activate_tab(): ?string {
+        return $this->_activenodeprimary;
         return $this->_activenodeprimary;
     /**
-    /**
+     * Sets the navigation overflow state. This allows developers to turn off the overflow menu if they perhaps are using
-     * Sets the navigation overflow state. This allows developers to turn off the overflow menu if they perhaps are using
+     * some other navigation to show settings.
-     * some other navigation to show settings.
+     *
+     * @param bool  $state  The state of whether to show the navigation overflow.
      */
-     * @param bool  $state  The state of whether to show the navigation overflow.
+    public function set_navigation_overflow_state(bool $state): void
      */
-    public function set_navigation_overflow_state(bool $state): void {
+        $this->_navigationoverflow = $state;
         $this->_navigationoverflow = $state;
     /**
-    /**
+     * Gets the navigation overflow state.
      * Gets the navigation overflow state.
-     *
+     * @return bool The navigation overflow state.
+     */
-     * @return bool The navigation overflow state.
+    public function get_navigation_overflow_state(): bool
      */
-    public function get_navigation_overflow_state(): bool {
+        return $this->_navigationoverflow;
         return $this->_navigationoverflow;
     /**
-    /**
+     * Set the status for displaying the course index.
-     * Set the status for displaying the course index.
+     *
+     * @param bool $state
      *     - `true` (default) if the course index should be shown.
-     * @param bool $state
+     *     - `false` if the course index should be hidden.
-     *     - `true` (default) if the course index should be shown.
+     */

Proyectos de Subversion Moodle

(root)/lib/pagelib.php – Rev 1468 → 1469