Search moodle.org's
Developer Documentation

See Release Notes

  • Bug fixes for general core bugs in 4.3.x will end 7 October 2024 (12 months).
  • Bug fixes for security issues in 4.3.x will end 21 April 2025 (18 months).
  • PHP version: minimum PHP 8.0.0 Note: minimum PHP version has increased since Moodle 4.1. PHP 8.2.x is supported too.
/lib/ -> pagelib.php (source)

Differences Between: [Versions 310 and 403] [Versions 311 and 403] [Versions 39 and 403] [Versions 400 and 403] [Versions 401 and 403] [Versions 402 and 403]

   1  <?php
   2  // This file is part of Moodle - http://moodle.org/
   3  //
   4  // Moodle is free software: you can redistribute it and/or modify
   5  // it under the terms of the GNU General Public License as published by
   6  // the Free Software Foundation, either version 3 of the License, or
   7  // (at your option) any later version.
   8  //
   9  // Moodle is distributed in the hope that it will be useful,
  10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  // GNU General Public License for more details.
  13  //
  14  // You should have received a copy of the GNU General Public License
  15  // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16  
  17  /**
  18   * This file contains the moodle_page class. There is normally a single instance
  19   * of this class in the $PAGE global variable. This class is a central repository
  20   * of information about the page we are building up to send back to the user.
  21   *
  22   * @package core
  23   * @category page
  24   * @copyright  1999 onwards Martin Dougiamas  {@link http://moodle.com}
  25   * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  26   */
  27  
  28  defined('MOODLE_INTERNAL') || die();
  29  
  30  use core\navigation\views\primary;
  31  use core\navigation\views\secondary;
  32  use core\navigation\output\primary as primaryoutput;
  33  use core\output\activity_header;
  34  
  35  /**
  36   * $PAGE is a central store of information about the current page we are
  37   * generating in response to the user's request.
  38   *
  39   * It does not do very much itself
  40   * except keep track of information, however, it serves as the access point to
  41   * some more significant components like $PAGE->theme, $PAGE->requires,
  42   * $PAGE->blocks, etc.
  43   *
  44   * @copyright 2009 Tim Hunt
  45   * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  46   * @since Moodle 2.0
  47   * @package core
  48   * @category page
  49   *
  50   * The following properties are alphabetical. Please keep it that way so that its
  51   * easy to maintain.
  52   *
  53   * @property-read string $activityname The type of activity we are in, for example 'forum' or 'quiz'.
  54   *      Will be null if this page is not within a module.
  55   * @property-read stdClass $activityrecord The row from the activities own database table (for example
  56   *      the forum or quiz table) that this page belongs to. Will be null
  57   *      if this page is not within a module.
  58   * @property-read activity_header $activityheader The activity header for the page, representing standard components
  59   *      displayed within the header
  60   * @property-read array $alternativeversions Mime type => object with ->url and ->title.
  61   * @property-read block_manager $blocks The blocks manager object for this page.
  62   * @property-read array $blockmanipulations
  63   * @property-read string $bodyclasses A string to use within the class attribute on the body tag.
  64   * @property-read string $bodyid A string to use as the id of the body tag.
  65   * @property-read string $button The HTML to go where the Turn editing on button normally goes.
  66   * @property-read bool $cacheable Defaults to true. Set to false to stop the page being cached at all.
  67   * @property-read array $categories An array of all the categories the page course belongs to,
  68   *      starting with the immediately containing category, and working out to
  69   *      the top-level category. This may be the empty array if we are in the
  70   *      front page course.
  71   * @property-read mixed $category The category that the page course belongs to.
  72   * @property-read cm_info $cm The course_module that this page belongs to. Will be null
  73   *      if this page is not within a module. This is a full cm object, as loaded
  74   *      by get_coursemodule_from_id or get_coursemodule_from_instance,
  75   *      so the extra modname and name fields are present.
  76   * @property-read context $context The main context to which this page belongs.
  77   * @property-read stdClass $course The current course that we are inside - a row from the
  78   *      course table. (Also available as $COURSE global.) If we are not inside
  79   *      an actual course, this will be the site course.
  80   * @property-read string $devicetypeinuse The name of the device type in use
  81   * @property-read string $docspath The path to the Help and documentation.
  82   * @property-read string $focuscontrol The id of the HTML element to be focused when the page has loaded.
  83   * @property-read bool $headerprinted True if the page header has already been printed.
  84   * @property-read string $heading The main heading that should be displayed at the top of the <body>.
  85   * @property-read string $headingmenu The menu (or actions) to display in the heading
  86   * @property-read array $layout_options An arrays with options for the layout file.
  87   * @property-read array $legacythemeinuse True if the legacy browser theme is in use.
  88   * @property-read navbar $navbar The navbar object used to display the navbar
  89   * @property-read secondary $secondarynav The secondary navigation object
  90   *      used to display the secondarynav in boost
  91   * @property-read primary $primarynav The primary navigation object used to display the primary nav in boost
  92   * @property-read primaryoutput $primarynavcombined The primary navigation object used to display the primary nav in boost
  93   * @property-read global_navigation $navigation The navigation structure for this page.
  94   * @property-read xhtml_container_stack $opencontainers Tracks XHTML tags on this page that have been opened but not closed.
  95   *      mainly for internal use by the rendering code.
  96   * @property-read string $pagelayout The general type of page this is. For example 'normal', 'popup', 'home'.
  97   *      Allows the theme to display things differently, if it wishes to.
  98   * @property-read string $pagetype The page type string, should be used as the id for the body tag in the theme.
  99   * @property-read int $periodicrefreshdelay The periodic refresh delay to use with meta refresh
 100   * @property-read page_requirements_manager $requires Tracks the JavaScript, CSS files, etc. required by this page.
 101   * @property-read string $requestip The IP address of the current request, null if unknown.
 102   * @property-read string $requestorigin The type of request 'web', 'ws', 'cli', 'restore', etc.
 103   * @property-read settings_navigation $settingsnav The settings navigation
 104   * @property-read int $state One of the STATE_... constants
 105   * @property-read string $subpage The subpage identifier, if any.
 106   * @property-read theme_config $theme The theme for this page.
 107   * @property-read string $title The title that should go in the <head> section of the HTML of this page.
 108   * @property-read moodle_url $url The moodle url object for this page.
 109   */
 110  class moodle_page {
 111  
 112      /** The state of the page before it has printed the header **/
 113      const STATE_BEFORE_HEADER = 0;
 114  
 115      /** The state the page is in temporarily while the header is being printed **/
 116      const STATE_PRINTING_HEADER = 1;
 117  
 118      /** The state the page is in while content is presumably being printed **/
 119      const STATE_IN_BODY = 2;
 120  
 121      /**
 122       * The state the page is when the footer has been printed and its function is
 123       * complete.
 124       */
 125      const STATE_DONE = 3;
 126  
 127      /**
 128       * The separator used for separating page title elements.
 129       */
 130      const TITLE_SEPARATOR = ' | ';
 131  
 132      /**
 133       * @var int The current state of the page. The state a page is within
 134       * determines what actions are possible for it.
 135       */
 136      protected $_state = self::STATE_BEFORE_HEADER;
 137  
 138      /**
 139       * @var stdClass The course currently associated with this page.
 140       * If not has been provided the front page course is used.
 141       */
 142      protected $_course = null;
 143  
 144      /**
 145       * @var cm_info If this page belongs to a module, this is the cm_info module
 146       * description object.
 147       */
 148      protected $_cm = null;
 149  
 150      /**
 151       * @var stdClass If $_cm is not null, then this will hold the corresponding
 152       * row from the modname table. For example, if $_cm->modname is 'quiz', this
 153       * will be a row from the quiz table.
 154       */
 155      protected $_module = null;
 156  
 157      /**
 158       * @var context The context that this page belongs to.
 159       */
 160      protected $_context = null;
 161  
 162      /**
 163       * @var array This holds any categories that $_course belongs to, starting with the
 164       * particular category it belongs to, and working out through any parent
 165       * categories to the top level. These are loaded progressively, if needed.
 166       * There are three states. $_categories = null initially when nothing is
 167       * loaded; $_categories = array($id => $cat, $parentid => null) when we have
 168       * loaded $_course->category, but not any parents; and a complete array once
 169       * everything is loaded.
 170       */
 171      protected $_categories = null;
 172  
 173      /**
 174       * @var array An array of CSS classes that should be added to the body tag in HTML.
 175       */
 176      protected $_bodyclasses = array();
 177  
 178      /**
 179       * @var string The title for the page. Used within the title tag in the HTML head.
 180       */
 181      protected $_title = '';
 182  
 183      /**
 184       * @var string The string to use as the heading of the page. Shown near the top of the
 185       * page within most themes.
 186       */
 187      protected $_heading = '';
 188  
 189      /**
 190       * @var string The pagetype is used to describe the page and defaults to a representation
 191       * of the physical path to the page e.g. my-index, mod-quiz-attempt
 192       */
 193      protected $_pagetype = null;
 194  
 195      /**
 196       * @var string The pagelayout to use when displaying this page. The
 197       * pagelayout needs to have been defined by the theme in use, or one of its
 198       * parents. By default base is used however standard is the more common layout.
 199       * Note that this gets automatically set by core during operations like
 200       * require_login.
 201       */
 202      protected $_pagelayout = 'base';
 203  
 204      /**
 205       * @var array List of theme layout options, these are ignored by core.
 206       * To be used in individual theme layout files only.
 207       */
 208      protected $_layout_options = null;
 209  
 210      /**
 211       * @var string An optional arbitrary parameter that can be set on pages where the context
 212       * and pagetype is not enough to identify the page.
 213       */
 214      protected $_subpage = '';
 215  
 216      /**
 217       * @var string Set a different path to use for the 'Help and documentation' link.
 218       * By default, it uses the path of the file for instance mod/quiz/attempt.
 219       */
 220      protected $_docspath = null;
 221  
 222      /**
 223       * @var string A legacy class that will be added to the body tag
 224       */
 225      protected $_legacyclass = null;
 226  
 227      /**
 228       * @var moodle_url The URL for this page. This is mandatory and must be set
 229       * before output is started.
 230       */
 231      protected $_url = null;
 232  
 233      /**
 234       * @var array An array of links to alternative versions of this page.
 235       * Primarily used for RSS versions of the current page.
 236       */
 237      protected $_alternateversions = array();
 238  
 239      /**
 240       * @var block_manager The blocks manager for this page. It is responsible for
 241       * the blocks and there content on this page.
 242       */
 243      protected $_blocks = null;
 244  
 245      /**
 246       * @var page_requirements_manager Page requirements manager. It is responsible
 247       * for all JavaScript and CSS resources required by this page.
 248       */
 249      protected $_requires = null;
 250  
 251      /** @var page_requirements_manager Saves the requirement manager object used before switching to to fragments one. */
 252      protected $savedrequires = null;
 253  
 254      /**
 255       * @var string The capability required by the user in order to edit blocks
 256       * and block settings on this page.
 257       */
 258      protected $_blockseditingcap = 'moodle/site:manageblocks';
 259  
 260      /**
 261       * @var bool An internal flag to record when block actions have been processed.
 262       * Remember block actions occur on the current URL and it is important that
 263       * even they are never executed more than once.
 264       */
 265      protected $_block_actions_done = false;
 266  
 267      /**
 268       * @var array An array of any other capabilities the current user must have
 269       * in order to editing the page and/or its content (not just blocks).
 270       */
 271      protected $_othereditingcaps = array();
 272  
 273      /**
 274       * @var bool Sets whether this page should be cached by the browser or not.
 275       * If it is set to true (default) the page is served with caching headers.
 276       */
 277      protected $_cacheable = true;
 278  
 279      /**
 280       * @var string Can be set to the ID of an element on the page, if done that
 281       * element receives focus when the page loads.
 282       */
 283      protected $_focuscontrol = '';
 284  
 285      /**
 286       * @var string HTML to go where the turn on editing button is located. This
 287       * is nearly a legacy item and not used very often any more.
 288       */
 289      protected $_button = '';
 290  
 291      /**
 292       * @var theme_config The theme to use with this page. This has to be properly
 293       * initialised via {@link moodle_page::initialise_theme_and_output()} which
 294       * happens magically before any operation that requires it.
 295       */
 296      protected $_theme = null;
 297  
 298      /**
 299       * @var global_navigation Contains the global navigation structure.
 300       */
 301      protected $_navigation = null;
 302  
 303      /**
 304       * @var settings_navigation Contains the settings navigation structure.
 305       */
 306      protected $_settingsnav = null;
 307  
 308      /**
 309       * @var flat_navigation Contains a list of nav nodes, most closely related to the current page.
 310       */
 311      protected $_flatnav = null;
 312  
 313      /**
 314       * @var secondary Contains the nav nodes that will appear
 315       * in the secondary navigation.
 316       */
 317      protected $_secondarynav = null;
 318  
 319      /**
 320       * @var primary Contains the nav nodes that will appear
 321       * in the primary navigation.
 322       */
 323      protected $_primarynav = null;
 324  
 325      /**
 326       * @var primaryoutput Contains the combined nav nodes that will appear
 327       * in the primary navigation. Includes - primarynav, langmenu, usermenu
 328       */
 329      protected $_primarynavcombined = null;
 330  
 331      /**
 332       * @var navbar Contains the navbar structure.
 333       */
 334      protected $_navbar = null;
 335  
 336      /**
 337       * @var string The menu (or actions) to display in the heading.
 338       */
 339      protected $_headingmenu = null;
 340  
 341      /**
 342       * @var array stack trace. Then the theme is initialised, we save the stack
 343       * trace, for use in error messages.
 344       */
 345      protected $_wherethemewasinitialised = null;
 346  
 347      /**
 348       * @var xhtml_container_stack Tracks XHTML tags on this page that have been
 349       * opened but not closed.
 350       */
 351      protected $_opencontainers;
 352  
 353      /**
 354       * @var int Sets the page to refresh after a given delay (in seconds) using
 355       * meta refresh in {@link standard_head_html()} in outputlib.php
 356       * If set to null(default) the page is not refreshed
 357       */
 358      protected $_periodicrefreshdelay = null;
 359  
 360      /**
 361       * @var array Associative array of browser shortnames (as used by check_browser_version)
 362       * and their minimum required versions
 363       */
 364      protected $_legacybrowsers = array('MSIE' => 6.0);
 365  
 366      /**
 367       * @var string Is set to the name of the device type in use.
 368       * This will we worked out when it is first used.
 369       */
 370      protected $_devicetypeinuse = null;
 371  
 372      /**
 373       * @var bool Used to determine if HTTPS should be required for login.
 374       */
 375      protected $_https_login_required = false;
 376  
 377      /**
 378       * @var bool Determines if popup notifications allowed on this page.
 379       * Code such as the quiz module disables popup notifications in situations
 380       * such as upgrading or completing a quiz.
 381       */
 382      protected $_popup_notification_allowed = true;
 383  
 384      /**
 385       * @var bool Is the settings menu being forced to display on this page (activities / resources only).
 386       * This is only used by themes that use the settings menu.
 387       */
 388      protected $_forcesettingsmenu = false;
 389  
 390      /**
 391       * @var array Array of header actions HTML to add to the page header actions menu.
 392       */
 393      protected $_headeractions = [];
 394  
 395      /**
 396       * @var bool Should the region main settings menu be rendered in the header.
 397       */
 398      protected $_regionmainsettingsinheader = false;
 399  
 400      /**
 401       * @var bool Should the secondary menu be rendered.
 402       */
 403      protected $_hassecondarynavigation = true;
 404  
 405      /**
 406       * @var bool Should the secondary menu be rendered as a tablist as opposed to a menubar.
 407       */
 408      protected $_hastablistsecondarynavigation = false;
 409  
 410      /**
 411       * @var string the key of the secondary node to be activated.
 412       */
 413      protected $_activekeysecondary = null;
 414  
 415      /**
 416       * @var string the key of the primary node to be activated.
 417       */
 418      protected $_activenodeprimary = null;
 419  
 420      /**
 421       * @var activity_header The activity header for the page.
 422       */
 423      protected $_activityheader;
 424  
 425      /**
 426       * @var bool The value of displaying the navigation overflow.
 427       */
 428      protected $_navigationoverflow = true;
 429  
 430      /**
 431       * @var bool Whether to override/remove all editing capabilities for blocks on the page.
 432       */
 433      protected $_forcelockallblocks = false;
 434  
 435      /**
 436       * Force the settings menu to be displayed on this page. This will only force the
 437       * settings menu on an activity / resource page that is being displayed on a theme that
 438       * uses a settings menu.
 439       *
 440       * @param bool $forced default of true, can be sent false to turn off the force.
 441       */
 442      public function force_settings_menu($forced = true) {
 443          $this->_forcesettingsmenu = $forced;
 444      }
 445  
 446      /**
 447       * Check to see if the settings menu is forced to display on this activity / resource page.
 448       * This only applies to themes that use the settings menu.
 449       *
 450       * @return bool True if the settings menu is forced to display.
 451       */
 452      public function is_settings_menu_forced() {
 453          return $this->_forcesettingsmenu;
 454      }
 455  
 456      // Magic getter methods =============================================================
 457      // Due to the __get magic below, you normally do not call these as $PAGE->magic_get_x
 458      // methods, but instead use the $PAGE->x syntax.
 459  
 460      /**
 461       * Please do not call this method directly, use the ->state syntax. {@link moodle_page::__get()}.
 462       * @return integer one of the STATE_XXX constants. You should not normally need
 463       * to use this in your code. It is intended for internal use by this class
 464       * and its friends like print_header, to check that everything is working as
 465       * expected. Also accessible as $PAGE->state.
 466       */
 467      protected function magic_get_state() {
 468          return $this->_state;
 469      }
 470  
 471      /**
 472       * Please do not call this method directly, use the ->headerprinted syntax. {@link moodle_page::__get()}.
 473       * @return bool has the header already been printed?
 474       */
 475      protected function magic_get_headerprinted() {
 476          return $this->_state >= self::STATE_IN_BODY;
 477      }
 478  
 479      /**
 480       * Please do not call this method directly, use the ->course syntax. {@link moodle_page::__get()}.
 481       * @return stdClass the current course that we are inside - a row from the
 482       * course table. (Also available as $COURSE global.) If we are not inside
 483       * an actual course, this will be the site course.
 484       */
 485      protected function magic_get_course() {
 486          global $SITE;
 487          if (is_null($this->_course)) {
 488              return $SITE;
 489          }
 490          return $this->_course;
 491      }
 492  
 493      /**
 494       * Please do not call this method directly, use the ->cm syntax. {@link moodle_page::__get()}.
 495       * @return cm_info the course_module that this page belongs to. Will be null
 496       * if this page is not within a module. This is a full cm object, as loaded
 497       * by get_coursemodule_from_id or get_coursemodule_from_instance,
 498       * so the extra modname and name fields are present.
 499       */
 500      protected function magic_get_cm() {
 501          return $this->_cm;
 502      }
 503  
 504      /**
 505       * Please do not call this method directly, use the ->activityrecord syntax. {@link moodle_page::__get()}.
 506       * @return stdClass the row from the activities own database table (for example
 507       * the forum or quiz table) that this page belongs to. Will be null
 508       * if this page is not within a module.
 509       */
 510      protected function magic_get_activityrecord() {
 511          if (is_null($this->_module) && !is_null($this->_cm)) {
 512              $this->load_activity_record();
 513          }
 514          return $this->_module;
 515      }
 516  
 517      /**
 518       * Please do not call this method directly, use the ->activityname syntax. {@link moodle_page::__get()}.
 519       * @return string the The type of activity we are in, for example 'forum' or 'quiz'.
 520       * Will be null if this page is not within a module.
 521       */
 522      protected function magic_get_activityname() {
 523          if (is_null($this->_cm)) {
 524              return null;
 525          }
 526          return $this->_cm->modname;
 527      }
 528  
 529      /**
 530       * Please do not call this method directly, use the ->category syntax. {@link moodle_page::__get()}.
 531       * @return stdClass|null the category that the page course belongs to. If there isn't one
 532       * (that is, if this is the front page course) returns null.
 533       */
 534      protected function magic_get_category() {
 535          $this->ensure_category_loaded();
 536          if (!empty($this->_categories)) {
 537              return reset($this->_categories);
 538          } else {
 539              return null;
 540          }
 541      }
 542  
 543      /**
 544       * Please do not call this method directly, use the ->categories syntax. {@link moodle_page::__get()}.
 545       * @return array an array of all the categories the page course belongs to,
 546       * starting with the immediately containing category, and working out to
 547       * the top-level category. This may be the empty array if we are in the
 548       * front page course.
 549       */
 550      protected function magic_get_categories() {
 551          $this->ensure_categories_loaded();
 552          return $this->_categories;
 553      }
 554  
 555      /**
 556       * Please do not call this method directly, use the ->context syntax. {@link moodle_page::__get()}.
 557       * @return context the main context to which this page belongs.
 558       */
 559      protected function magic_get_context() {
 560          global $CFG;
 561          if (is_null($this->_context)) {
 562              if (CLI_SCRIPT or NO_MOODLE_COOKIES) {
 563                  // Cli scripts work in system context, do not annoy devs with debug info.
 564                  // Very few scripts do not use cookies, we can safely use system as default context there.
 565              } else if (AJAX_SCRIPT && $CFG->debugdeveloper) {
 566                  // Throw exception inside AJAX script in developer mode, otherwise the debugging message may be missed.
 567                  throw new coding_exception('$PAGE->context was not set. You may have forgotten '
 568                      .'to call require_login() or $PAGE->set_context()');
 569              } else {
 570                  debugging('Coding problem: $PAGE->context was not set. You may have forgotten '
 571                      .'to call require_login() or $PAGE->set_context(). The page may not display '
 572                      .'correctly as a result');
 573              }
 574              $this->_context = context_system::instance();
 575          }
 576          return $this->_context;
 577      }
 578  
 579      /**
 580       * Please do not call this method directly, use the ->pagetype syntax. {@link moodle_page::__get()}.
 581       * @return string e.g. 'my-index' or 'mod-quiz-attempt'.
 582       */
 583      protected function magic_get_pagetype() {
 584          global $CFG;
 585          if (is_null($this->_pagetype) || isset($CFG->pagepath)) {
 586              $this->initialise_default_pagetype();
 587          }
 588          return $this->_pagetype;
 589      }
 590  
 591      /**
 592       * Please do not call this method directly, use the ->pagetype syntax. {@link moodle_page::__get()}.
 593       * @return string The id to use on the body tag, uses {@link magic_get_pagetype()}.
 594       */
 595      protected function magic_get_bodyid() {
 596          return 'page-'.$this->pagetype;
 597      }
 598  
 599      /**
 600       * Please do not call this method directly, use the ->pagelayout syntax. {@link moodle_page::__get()}.
 601       * @return string the general type of page this is. For example 'standard', 'popup', 'home'.
 602       *      Allows the theme to display things differently, if it wishes to.
 603       */
 604      protected function magic_get_pagelayout() {
 605          return $this->_pagelayout;
 606      }
 607  
 608      /**
 609       * Please do not call this method directly, use the ->layout_options syntax. {@link moodle_page::__get()}.
 610       * @return array returns arrays with options for layout file
 611       */
 612      protected function magic_get_layout_options() {
 613          if (!is_array($this->_layout_options)) {
 614              $this->_layout_options = $this->_theme->pagelayout_options($this->pagelayout);
 615          }
 616          return $this->_layout_options;
 617      }
 618  
 619      /**
 620       * Please do not call this method directly, use the ->subpage syntax. {@link moodle_page::__get()}.
 621       * @return string The subpage identifier, if any.
 622       */
 623      protected function magic_get_subpage() {
 624          return $this->_subpage;
 625      }
 626  
 627      /**
 628       * Please do not call this method directly, use the ->bodyclasses syntax. {@link moodle_page::__get()}.
 629       * @return string the class names to put on the body element in the HTML.
 630       */
 631      protected function magic_get_bodyclasses() {
 632          return implode(' ', array_keys($this->_bodyclasses));
 633      }
 634  
 635      /**
 636       * Please do not call this method directly, use the ->title syntax. {@link moodle_page::__get()}.
 637       * @return string the title that should go in the <head> section of the HTML of this page.
 638       */
 639      protected function magic_get_title() {
 640          return $this->_title;
 641      }
 642  
 643      /**
 644       * Please do not call this method directly, use the ->heading syntax. {@link moodle_page::__get()}.
 645       * @return string the main heading that should be displayed at the top of the <body>.
 646       */
 647      protected function magic_get_heading() {
 648          return $this->_heading;
 649      }
 650  
 651      /**
 652       * Please do not call this method directly, use the ->heading syntax. {@link moodle_page::__get()}.
 653       * @return string The menu (or actions) to display in the heading
 654       */
 655      protected function magic_get_headingmenu() {
 656          return $this->_headingmenu;
 657      }
 658  
 659      /**
 660       * Please do not call this method directly, use the ->docspath syntax. {@link moodle_page::__get()}.
 661       * @return string the path to the Help and documentation.
 662       */
 663      protected function magic_get_docspath() {
 664          if (is_string($this->_docspath)) {
 665              return $this->_docspath;
 666          } else {
 667              return str_replace('-', '/', $this->pagetype);
 668          }
 669      }
 670  
 671      /**
 672       * Please do not call this method directly, use the ->url syntax. {@link moodle_page::__get()}.
 673       * @return moodle_url the clean URL required to load the current page. (You
 674       * should normally use this in preference to $ME or $FULLME.)
 675       */
 676      protected function magic_get_url() {
 677          global $FULLME;
 678          if (is_null($this->_url)) {
 679              debugging('This page did not call $PAGE->set_url(...). Using '.s($FULLME), DEBUG_DEVELOPER);
 680              $this->_url = new moodle_url($FULLME);
 681              // Make sure the guessed URL cannot lead to dangerous redirects.
 682              $this->_url->remove_params('sesskey');
 683          }
 684          return new moodle_url($this->_url); // Return a clone for safety.
 685      }
 686  
 687      /**
 688       * The list of alternate versions of this page.
 689       * @return array mime type => object with ->url and ->title.
 690       */
 691      protected function magic_get_alternateversions() {
 692          return $this->_alternateversions;
 693      }
 694  
 695      /**
 696       * Please do not call this method directly, use the ->blocks syntax. {@link moodle_page::__get()}.
 697       * @return block_manager the blocks manager object for this page.
 698       */
 699      protected function magic_get_blocks() {
 700          global $CFG;
 701          if (is_null($this->_blocks)) {
 702              if (!empty($CFG->blockmanagerclass)) {
 703                  if (!empty($CFG->blockmanagerclassfile)) {
 704                      require_once($CFG->blockmanagerclassfile);
 705                  }
 706                  $classname = $CFG->blockmanagerclass;
 707              } else {
 708                  $classname = 'block_manager';
 709              }
 710              $this->_blocks = new $classname($this);
 711          }
 712          return $this->_blocks;
 713      }
 714  
 715      /**
 716       * Please do not call this method directly, use the ->requires syntax. {@link moodle_page::__get()}.
 717       * @return page_requirements_manager tracks the JavaScript, CSS files, etc. required by this page.
 718       */
 719      protected function magic_get_requires() {
 720          if (is_null($this->_requires)) {
 721              $this->_requires = new page_requirements_manager();
 722          }
 723          return $this->_requires;
 724      }
 725  
 726      /**
 727       * Please do not call this method directly, use the ->cacheable syntax. {@link moodle_page::__get()}.
 728       * @return bool can this page be cached by the user's browser.
 729       */
 730      protected function magic_get_cacheable() {
 731          return $this->_cacheable;
 732      }
 733  
 734      /**
 735       * Please do not call this method directly, use the ->focuscontrol syntax. {@link moodle_page::__get()}.
 736       * @return string the id of the HTML element to be focused when the page has loaded.
 737       */
 738      protected function magic_get_focuscontrol() {
 739          return $this->_focuscontrol;
 740      }
 741  
 742      /**
 743       * Please do not call this method directly, use the ->button syntax. {@link moodle_page::__get()}.
 744       * @return string the HTML to go where the Turn editing on button normally goes.
 745       */
 746      protected function magic_get_button() {
 747          return $this->_button;
 748      }
 749  
 750      /**
 751       * Please do not call this method directly, use the ->theme syntax. {@link moodle_page::__get()}.
 752       * @return theme_config the initialised theme for this page.
 753       */
 754      protected function magic_get_theme() {
 755          if (is_null($this->_theme)) {
 756              $this->initialise_theme_and_output();
 757          }
 758          return $this->_theme;
 759      }
 760  
 761      /**
 762       * Returns an array of minipulations or false if there are none to make.
 763       *
 764       * @since Moodle 2.5.1 2.6
 765       * @return bool|array
 766       */
 767      protected function magic_get_blockmanipulations() {
 768          if (!right_to_left()) {
 769              return false;
 770          }
 771          if (is_null($this->_theme)) {
 772              $this->initialise_theme_and_output();
 773          }
 774          return $this->_theme->blockrtlmanipulations;
 775      }
 776  
 777      /**
 778       * Please do not call this method directly, use the ->devicetypeinuse syntax. {@link moodle_page::__get()}.
 779       * @return string The device type being used.
 780       */
 781      protected function magic_get_devicetypeinuse() {
 782          if (empty($this->_devicetypeinuse)) {
 783              $this->_devicetypeinuse = core_useragent::get_user_device_type();
 784          }
 785          return $this->_devicetypeinuse;
 786      }
 787  
 788      /**
 789       * Please do not call this method directly use the ->periodicrefreshdelay syntax
 790       * {@link moodle_page::__get()}
 791       * @return int The periodic refresh delay to use with meta refresh
 792       */
 793      protected function magic_get_periodicrefreshdelay() {
 794          return $this->_periodicrefreshdelay;
 795      }
 796  
 797      /**
 798       * Please do not call this method directly use the ->opencontainers syntax. {@link moodle_page::__get()}
 799       * @return xhtml_container_stack tracks XHTML tags on this page that have been opened but not closed.
 800       *      mainly for internal use by the rendering code.
 801       */
 802      protected function magic_get_opencontainers() {
 803          if (is_null($this->_opencontainers)) {
 804              $this->_opencontainers = new xhtml_container_stack();
 805          }
 806          return $this->_opencontainers;
 807      }
 808  
 809      /**
 810       * Return the navigation object
 811       * @return global_navigation
 812       */
 813      protected function magic_get_navigation() {
 814          if ($this->_navigation === null) {
 815              $this->_navigation = new global_navigation($this);
 816          }
 817          return $this->_navigation;
 818      }
 819  
 820      /**
 821       * Return a navbar object
 822       * @return navbar
 823       */
 824      protected function magic_get_navbar() {
 825          if ($this->_navbar === null) {
 826              $this->_navbar = new navbar($this);
 827          }
 828          return $this->_navbar;
 829      }
 830  
 831      /**
 832       * Returns the settings navigation object
 833       * @return settings_navigation
 834       */
 835      protected function magic_get_settingsnav() {
 836          if ($this->_settingsnav === null) {
 837              $this->_settingsnav = new settings_navigation($this);
 838              $this->_settingsnav->initialise();
 839          }
 840          return $this->_settingsnav;
 841      }
 842  
 843      /**
 844       * Returns the flat navigation object
 845       * @return flat_navigation
 846       */
 847      protected function magic_get_flatnav() {
 848          if ($this->_flatnav === null) {
 849              $this->_flatnav = new flat_navigation($this);
 850              $this->_flatnav->initialise();
 851          }
 852          return $this->_flatnav;
 853      }
 854  
 855      /**
 856       * Returns the activity header object
 857       * @return activity_header
 858       */
 859      protected function magic_get_activityheader(): activity_header {
 860          global $USER;
 861          if ($this->_activityheader === null) {
 862              $class = activity_header::class;
 863              // Try and load a custom class first.
 864              if (class_exists("mod_{$this->activityname}\\output\\activity_header")) {
 865                  $class = "mod_{$this->activityname}\\output\\activity_header";
 866              }
 867  
 868              $this->_activityheader = new $class($this, $USER);
 869          }
 870          return $this->_activityheader;
 871      }
 872  
 873      /**
 874       * Returns the secondary navigation object
 875       *
 876       * @todo MDL-74939 Remove support for old 'local\views\secondary' class location
 877       * @return secondary
 878       */
 879      protected function magic_get_secondarynav() {
 880          if ($this->_secondarynav === null) {
 881              $class = 'core\navigation\views\secondary';
 882              // Try and load a custom class first.
 883              if (class_exists("mod_{$this->activityname}\\navigation\\views\\secondary")) {
 884                  $class = "mod_{$this->activityname}\\navigation\\views\\secondary";
 885              } else if (class_exists("mod_{$this->activityname}\\local\\views\\secondary")) {
 886                  // For backwards compatibility, support the old location for this class (it was in a
 887                  // 'local' namespace which shouldn't be used for core APIs).
 888                  debugging("The class mod_{$this->activityname}}\\local\\views\\secondary uses a deprecated " .
 889                          "namespace. Please move it to mod_{$this->activityname}\\navigation\\views\\secondary.",
 890                          DEBUG_DEVELOPER);
 891                  $class = "mod_{$this->activityname}\\local\\views\\secondary";
 892              }
 893  
 894              $this->_secondarynav = new $class($this);
 895              $this->_secondarynav->initialise();
 896          }
 897          return $this->_secondarynav;
 898      }
 899  
 900      /**
 901       * Returns the primary navigation object
 902       * @return primary
 903       */
 904      protected function magic_get_primarynav() {
 905          if ($this->_primarynav === null) {
 906              $this->_primarynav = new primary($this);
 907              $this->_primarynav->initialise();
 908          }
 909          return $this->_primarynav;
 910      }
 911  
 912      /**
 913       * Returns the primary navigation object
 914       * @return primaryoutput
 915       */
 916      protected function magic_get_primarynavcombined() {
 917          if ($this->_primarynavcombined === null) {
 918              $this->_primarynavcombined = new primaryoutput($this);
 919          }
 920          return $this->_primarynavcombined;
 921      }
 922  
 923      /**
 924       * Returns request IP address.
 925       *
 926       * @return string IP address or null if unknown
 927       */
 928      protected function magic_get_requestip() {
 929          return getremoteaddr(null);
 930      }
 931  
 932      /**
 933       * Returns the origin of current request.
 934       *
 935       * Note: constants are not required because we need to use these values in logging and reports.
 936       *
 937       * @return string 'web', 'ws', 'cli', 'restore', etc.
 938       */
 939      protected function magic_get_requestorigin() {
 940          if (class_exists('restore_controller', false) && restore_controller::is_executing()) {
 941              return 'restore';
 942          }
 943  
 944          if (WS_SERVER) {
 945              return 'ws';
 946          }
 947  
 948          if (CLI_SCRIPT) {
 949              return 'cli';
 950          }
 951  
 952          return 'web';
 953      }
 954  
 955      /**
 956       * PHP overloading magic to make the $PAGE->course syntax work by redirecting
 957       * it to the corresponding $PAGE->magic_get_course() method if there is one, and
 958       * throwing an exception if not.
 959       *
 960       * @param string $name property name
 961       * @return mixed
 962       * @throws coding_exception
 963       */
 964      public function __get($name) {
 965          $getmethod = 'magic_get_' . $name;
 966          if (method_exists($this, $getmethod)) {
 967              return $this->$getmethod();
 968          } else {
 969              throw new coding_exception('Unknown property ' . $name . ' of $PAGE.');
 970          }
 971      }
 972  
 973      /**
 974       * PHP overloading magic to catch obvious coding errors.
 975       *
 976       * This method has been created to catch obvious coding errors where the
 977       * developer has tried to set a page property using $PAGE->key = $value.
 978       * In the moodle_page class all properties must be set using the appropriate
 979       * $PAGE->set_something($value) method.
 980       *
 981       * @param string $name property name
 982       * @param mixed $value Value
 983       * @return void Throws exception if field not defined in page class
 984       * @throws coding_exception
 985       */
 986      public function __set($name, $value) {
 987          if (method_exists($this, 'set_' . $name)) {
 988              throw new coding_exception('Invalid attempt to modify page object', "Use \$PAGE->set_$name() instead.");
 989          } else {
 990              throw new coding_exception('Invalid attempt to modify page object', "Unknown property $name");
 991          }
 992      }
 993  
 994      // Other information getting methods ==========================================.
 995  
 996      /**
 997       * Returns instance of page renderer
 998       *
 999       * @param string $component name such as 'core', 'mod_forum' or 'qtype_multichoice'.
1000       * @param string $subtype optional subtype such as 'news' resulting to 'mod_forum_news'
1001       * @param string $target one of rendering target constants
1002       * @return renderer_base
1003       */
1004      public function get_renderer($component, $subtype = null, $target = null) {
1005          if ($this->pagelayout === 'maintenance') {
1006              // If the page is using the maintenance layout then we're going to force target to maintenance.
1007              // This leads to a special core renderer that is designed to block access to API's that are likely unavailable for this
1008              // page layout.
1009              $target = RENDERER_TARGET_MAINTENANCE;
1010          }
1011          return $this->magic_get_theme()->get_renderer($this, $component, $subtype, $target);
1012      }
1013  
1014      /**
1015       * Checks to see if there are any items on the navbar object
1016       *
1017       * @return bool true if there are, false if not
1018       */
1019      public function has_navbar() {
1020          if ($this->_navbar === null) {
1021              $this->_navbar = new navbar($this);
1022          }
1023          return $this->_navbar->has_items();
1024      }
1025  
1026      /**
1027       * Switches from the regular requirements manager to the fragment requirements manager to
1028       * capture all necessary JavaScript to display a chunk of HTML such as an mform. This is for use
1029       * by the get_fragment() web service and not for use elsewhere.
1030       */
1031      public function start_collecting_javascript_requirements() {
1032          global $CFG;
1033          require_once($CFG->libdir.'/outputfragmentrequirementslib.php');
1034  
1035          // Check that the requirements manager has not already been switched.
1036          if (get_class($this->_requires) == 'fragment_requirements_manager') {
1037              throw new coding_exception('JavaScript collection has already been started.');
1038          }
1039          // The header needs to have been called to flush out the generic JavaScript for the page. This allows only
1040          // JavaScript for the fragment to be collected. _wherethemewasinitialised is set when header() is called.
1041          if (!empty($this->_wherethemewasinitialised)) {
1042              // Change the current requirements manager over to the fragment manager to capture JS.
1043              $this->savedrequires = $this->_requires;
1044              $this->_requires = new fragment_requirements_manager();
1045          } else {
1046              throw new coding_exception('$OUTPUT->header() needs to be called before collecting JavaScript requirements.');
1047          }
1048      }
1049  
1050      /**
1051       * Switches back from collecting fragment JS requirement to the original requirement manager
1052       */
1053      public function end_collecting_javascript_requirements() {
1054          if ($this->savedrequires === null) {
1055              throw new coding_exception('JavaScript collection has not been started.');
1056          }
1057          $this->_requires = $this->savedrequires;
1058          $this->savedrequires = null;
1059      }
1060  
1061      /**
1062       * Should the current user see this page in editing mode.
1063       * That is, are they allowed to edit this page, and are they currently in
1064       * editing mode.
1065       * @return bool
1066       */
1067      public function user_is_editing() {
1068          global $USER;
1069          return !empty($USER->editing) && $this->user_allowed_editing();
1070      }
1071  
1072      /**
1073       * Does the user have permission to edit blocks on this page.
1074       * Can be forced to false by calling the force_lock_all_blocks() method.
1075       *
1076       * @return bool
1077       */
1078      public function user_can_edit_blocks() {
1079          return $this->_forcelockallblocks ? false : has_capability($this->_blockseditingcap, $this->_context);
1080      }
1081  
1082      /**
1083       * Does the user have permission to see this page in editing mode.
1084       * @return bool
1085       */
1086      public function user_allowed_editing() {
1087          return has_any_capability($this->all_editing_caps(), $this->_context);
1088      }
1089  
1090      /**
1091       * Get a description of this page. Normally displayed in the footer in developer debug mode.
1092       * @return string
1093       */
1094      public function debug_summary() {
1095          $summary = '';
1096          $summary .= 'General type: ' . $this->pagelayout . '. ';
1097          if (!during_initial_install()) {
1098              $summary .= 'Context ' . $this->context->get_context_name() . ' (context id ' . $this->_context->id . '). ';
1099          }
1100          $summary .= 'Page type ' . $this->pagetype .  '. ';
1101          if ($this->subpage) {
1102              $summary .= 'Sub-page ' . $this->subpage .  '. ';
1103          }
1104          return $summary;
1105      }
1106  
1107      // Setter methods =============================================================.
1108  
1109      /**
1110       * Set the state.
1111       *
1112       * The state must be one of that STATE_... constants, and the state is only allowed to advance one step at a time.
1113       *
1114       * @param int $state The new state.
1115       * @throws coding_exception
1116       */
1117      public function set_state($state) {
1118          if ($state != $this->_state + 1 || $state > self::STATE_DONE) {
1119              throw new coding_exception('Invalid state passed to moodle_page::set_state. We are in state ' .
1120                      $this->_state . ' and state ' . $state . ' was requested.');
1121          }
1122  
1123          if ($state == self::STATE_PRINTING_HEADER) {
1124              $this->starting_output();
1125          }
1126  
1127          $this->_state = $state;
1128      }
1129  
1130      /**
1131       * Set the current course. This sets both $PAGE->course and $COURSE. It also
1132       * sets the right theme and locale.
1133       *
1134       * Normally you don't need to call this function yourself, require_login will
1135       * call it for you if you pass a $course to it. You can use this function
1136       * on pages that do need to call require_login().
1137       *
1138       * Sets $PAGE->context to the course context, if it is not already set.
1139       *
1140       * @param stdClass $course the course to set as the global course.
1141       * @throws coding_exception
1142       */
1143      public function set_course($course) {
1144          global $COURSE, $PAGE, $CFG, $SITE;
1145  
1146          if (empty($course->id)) {
1147              throw new coding_exception('$course passed to moodle_page::set_course does not look like a proper course object.');
1148          }
1149  
1150          $this->ensure_theme_not_set();
1151  
1152          if (!empty($this->_course->id) && $this->_course->id != $course->id) {
1153              $this->_categories = null;
1154          }
1155  
1156          $this->_course = clone($course);
1157  
1158          if ($this === $PAGE) {
1159              $COURSE = $this->_course;
1160              moodle_setlocale();
1161          }
1162  
1163          if (!$this->_context) {
1164              $this->set_context(context_course::instance($this->_course->id));
1165          }
1166  
1167          // Notify course format that this page is set for the course.
1168          if ($this->_course->id != $SITE->id) {
1169              require_once($CFG->dirroot.'/course/lib.php');
1170              $courseformat = course_get_format($this->_course);
1171              $this->add_body_class('format-'. $courseformat->get_format());
1172              $courseformat->page_set_course($this);
1173          } else {
1174              $this->add_body_class('format-site');
1175          }
1176      }
1177  
1178      /**
1179       * Set the main context to which this page belongs.
1180       *
1181       * @param context $context a context object. You normally get this with context_xxxx::instance().
1182       */
1183      public function set_context($context) {
1184          if ($context === null) {
1185              // Extremely ugly hack which sets context to some value in order to prevent warnings,
1186              // use only for core error handling!!!!
1187              if (!$this->_context) {
1188                  $this->_context = context_system::instance();
1189              }
1190              return;
1191          }
1192          // Ideally we should set context only once.
1193          if (isset($this->_context) && $context->id !== $this->_context->id) {
1194              $current = $this->_context->contextlevel;
1195              if ($current == CONTEXT_SYSTEM or $current == CONTEXT_COURSE) {
1196                  // Hmm - not ideal, but it might produce too many warnings due to the design of require_login.
1197              } else if ($current == CONTEXT_MODULE and ($parentcontext = $context->get_parent_context()) and
1198                  $this->_context->id == $parentcontext->id) {
1199                  // Hmm - most probably somebody did require_login() and after that set the block context.
1200              } else {
1201                  // We do not want devs to do weird switching of context levels on the fly because we might have used
1202                  // the context already such as in text filter in page title.
1203                  debugging("Coding problem: unsupported modification of PAGE->context from {$current} to {$context->contextlevel}");
1204              }
1205          }
1206  
1207          $this->_context = $context;
1208      }
1209  
1210      /**
1211       * The course module that this page belongs to (if it does belong to one).
1212       *
1213       * @param stdClass|cm_info $cm a record from course_modules table or cm_info from get_fast_modinfo().
1214       * @param stdClass $course
1215       * @param stdClass $module
1216       * @return void
1217       * @throws coding_exception
1218       */
1219      public function set_cm($cm, $course = null, $module = null) {
1220          global $DB, $CFG, $SITE;
1221  
1222          if (!isset($cm->id) || !isset($cm->course)) {
1223              throw new coding_exception('Invalid $cm. It has to be instance of cm_info or record from the course_modules table.');
1224          }
1225  
1226          if (!$this->_course || $this->_course->id != $cm->course) {
1227              if (!$course) {
1228                  $course = $DB->get_record('course', array('id' => $cm->course), '*', MUST_EXIST);
1229              }
1230              if ($course->id != $cm->course) {
1231                  throw new coding_exception('The course you passed to $PAGE->set_cm does not correspond to the $cm.');
1232              }
1233              $this->set_course($course);
1234          }
1235  
1236          // Make sure we have a $cm from get_fast_modinfo as this contains activity access details.
1237          if (!($cm instanceof cm_info)) {
1238              $modinfo = get_fast_modinfo($this->_course);
1239              $cm = $modinfo->get_cm($cm->id);
1240          }
1241          $this->_cm = $cm;
1242  
1243          // Unfortunately the context setting is a mess.
1244          // Let's try to work around some common block problems and show some debug messages.
1245          if (empty($this->_context) or $this->_context->contextlevel != CONTEXT_BLOCK) {
1246              $context = context_module::instance($cm->id);
1247              $this->set_context($context);
1248          }
1249  
1250          if ($module) {
1251              $this->set_activity_record($module);
1252          }
1253  
1254          // Notify course format that this page is set for the course module.
1255          if ($this->_course->id != $SITE->id) {
1256              require_once($CFG->dirroot.'/course/lib.php');
1257              course_get_format($this->_course)->page_set_cm($this);
1258          }
1259      }
1260  
1261      /**
1262       * Sets the activity record. This could be a row from the main table for a
1263       * module. For instance if the current module (cm) is a forum this should be a row
1264       * from the forum table.
1265       *
1266       * @param stdClass $module A row from the main database table for the module that this page belongs to.
1267       * @throws coding_exception
1268       */
1269      public function set_activity_record($module) {
1270          if (is_null($this->_cm)) {
1271              throw new coding_exception('You cannot call $PAGE->set_activity_record until after $PAGE->cm has been set.');
1272          }
1273          if ($module->id != $this->_cm->instance || $module->course != $this->_course->id) {
1274              throw new coding_exception('The activity record does not seem to correspond to the cm that has been set.');
1275          }
1276          $this->_module = $module;
1277      }
1278  
1279      /**
1280       * Sets the pagetype to use for this page.
1281       *
1282       * Normally you do not need to set this manually, it is automatically created
1283       * from the script name. However, on some pages this is overridden.
1284       * For example the page type for course/view.php includes the course format,
1285       * for example 'course-view-weeks'. This gets used as the id attribute on
1286       * <body> and also for determining which blocks are displayed.
1287       *
1288       * @param string $pagetype e.g. 'my-index' or 'mod-quiz-attempt'.
1289       */
1290      public function set_pagetype($pagetype) {
1291          $this->_pagetype = $pagetype;
1292      }
1293  
1294      /**
1295       * Sets the layout to use for this page.
1296       *
1297       * The page layout determines how the page will be displayed, things such as
1298       * block regions, content areas, etc are controlled by the layout.
1299       * The theme in use for the page will determine that the layout contains.
1300       *
1301       * This properly defaults to 'base', so you only need to call this function if
1302       * you want something different. The exact range of supported layouts is specified
1303       * in the standard theme.
1304       *
1305       * For an idea of the common page layouts see
1306       * {@link https://docs.moodle.org/dev/Themes_overview#Layouts}
1307       * But please keep in mind that it may be (and normally is) out of date.
1308       * The only place to find an accurate up-to-date list of the page layouts
1309       * available for your version of Moodle is {@link theme/base/config.php}
1310       *
1311       * @param string $pagelayout the page layout this is. For example 'popup', 'home'.
1312       */
1313      public function set_pagelayout($pagelayout) {
1314          global $SESSION;
1315  
1316          if (!empty($SESSION->forcepagelayout)) {
1317              $this->_pagelayout = $SESSION->forcepagelayout;
1318          } else {
1319              // Uncomment this to debug theme pagelayout issues like missing blocks.
1320              // if (!empty($this->_wherethemewasinitialised) && $pagelayout != $this->_pagelayout)
1321              //     debugging('Page layout has already been set and cannot be changed.', DEBUG_DEVELOPER);
1322              $this->_pagelayout = $pagelayout;
1323          }
1324      }
1325  
1326      /**
1327       * If context->id and pagetype are not enough to uniquely identify this page,
1328       * then you can set a subpage id as well. For example, the tags page sets
1329       *
1330       * @param string $subpage an arbitrary identifier that, along with context->id
1331       *      and pagetype, uniquely identifies this page.
1332       */
1333      public function set_subpage($subpage) {
1334          if (empty($subpage)) {
1335              $this->_subpage = '';
1336          } else {
1337              $this->_subpage = $subpage;
1338          }
1339      }
1340  
1341      /**
1342       * Force set secondary_nav. Useful in cases where we dealing with non course modules. e.g. blocks, tools.
1343       * @param secondary $nav
1344       */
1345      public function set_secondarynav(secondary $nav) {
1346          $this->_secondarynav = $nav;
1347      }
1348  
1349      /**
1350       * Adds a CSS class to the body tag of the page.
1351       *
1352       * @param string $class add this class name ot the class attribute on the body tag.
1353       * @throws coding_exception
1354       */
1355      public function add_body_class($class) {
1356          if ($this->_state > self::STATE_BEFORE_HEADER) {
1357              throw new coding_exception('Cannot call moodle_page::add_body_class after output has been started.');
1358          }
1359          $this->_bodyclasses[$class] = 1;
1360      }
1361  
1362      /**
1363       * Adds an array of body classes to the body tag of this page.
1364       *
1365       * @param array $classes this utility method calls add_body_class for each array element.
1366       */
1367      public function add_body_classes($classes) {
1368          foreach ($classes as $class) {
1369              $this->add_body_class($class);
1370          }
1371      }
1372  
1373      /**
1374       * Sets the title for the page.
1375       *
1376       * This is normally used within the title tag in the head of the page.
1377       *
1378       * Some tips for providing a meaningful page title:
1379       * - The page title must be accurate and informative.
1380       * - If the page causes a change of context (e.g. a search functionality), it should describe the result or change of context
1381       *   to the user.
1382       * - It should be concise.
1383       * - If possible, it should uniquely identify the page.
1384       * - The most identifying information should come first. (e.g. Submit assignment | Assignment | Moodle)
1385       *
1386       * For more information, see
1387       * {@link https://www.w3.org/WAI/WCAG21/Understanding/page-titled Understanding Success Criterion 2.4.2: Page Titled}
1388       *
1389       * @param string $title the title that should go in the <head> section of the HTML of this page.
1390       * @param bool $appendsitename Appends site name at the end of the given title. It is encouraged to append the site name as this
1391       *                              especially helps with accessibility. If it's necessary to override this, please keep in mind
1392       *                              to ensure that the title provides a concise summary of the page being displayed.
1393       */
1394      public function set_title($title, bool $appendsitename = true) {
1395          global $CFG;
1396  
1397          $title = format_string($title);
1398          $title = strip_tags($title);
1399          $title = str_replace('"', '&quot;', $title);
1400  
1401          if ($appendsitename) {
1402              // Append the site name at the end of the page title.
1403              $sitenamedisplay = 'shortname';
1404              if (!empty($CFG->sitenameintitle)) {
1405                  $sitenamedisplay = $CFG->sitenameintitle;
1406              }
1407              $site = get_site();
1408              if (empty(trim($site->{$sitenamedisplay} ?? ''))) {
1409                  // If for some reason the site name is not yet set, fall back to 'Moodle'.
1410                  $title .= self::TITLE_SEPARATOR . 'Moodle';
1411              } else {
1412                  $title .= self::TITLE_SEPARATOR . format_string($site->{$sitenamedisplay});
1413              }
1414          }
1415  
1416          $this->_title = $title;
1417      }
1418  
1419      /**
1420       * Sets the heading to use for the page.
1421       * This is normally used as the main heading at the top of the content.
1422       *
1423       * @param string $heading the main heading that should be displayed at the top of the <body>.
1424       * @param bool $applyformatting apply format_string() - by default true.
1425       */
1426      public function set_heading($heading, bool $applyformatting = true) {
1427          $this->_heading = $applyformatting ? format_string($heading) : clean_text($heading);
1428      }
1429  
1430      /**
1431       * Sets some HTML to use next to the heading {@link moodle_page::set_heading()}
1432       *
1433       * @param string $menu The menu/content to show in the heading
1434       */
1435      public function set_headingmenu($menu) {
1436          $this->_headingmenu = $menu;
1437      }
1438  
1439      /**
1440       * Set the course category this page belongs to manually.
1441       *
1442       * This automatically sets $PAGE->course to be the site course. You cannot
1443       * use this method if you have already set $PAGE->course - in that case,
1444       * the category must be the one that the course belongs to. This also
1445       * automatically sets the page context to the category context.
1446       *
1447       * @param int $categoryid The id of the category to set.
1448       * @throws coding_exception
1449       */
1450      public function set_category_by_id($categoryid) {
1451          global $SITE;
1452          if (!is_null($this->_course)) {
1453              throw new coding_exception('Course has already been set. You cannot change the category now.');
1454          }
1455          if (is_array($this->_categories)) {
1456              throw new coding_exception('Course category has already been set. You cannot to change it now.');
1457          }
1458          $this->ensure_theme_not_set();
1459          $this->set_course($SITE);
1460          $this->load_category($categoryid);
1461          $this->set_context(context_coursecat::instance($categoryid));
1462      }
1463  
1464      /**
1465       * Set a different path to use for the 'Help and documentation' link.
1466       *
1467       * By default, it uses the pagetype, which is normally the same as the
1468       * script name. So, for example, for mod/quiz/attempt.php, pagetype is
1469       * mod-quiz-attempt, and so docspath is mod/quiz/attempt.
1470       *
1471       * @param string $path the path to use at the end of the moodle docs URL.
1472       */
1473      public function set_docs_path($path) {
1474          $this->_docspath = $path;
1475      }
1476  
1477      /**
1478       * You should call this method from every page to set the URL that should be used to return to this page.
1479       *
1480       * Used, for example, by the blocks editing UI to know where to return the
1481       * user after an action.
1482       * For example, course/view.php does:
1483       *      $id = optional_param('id', 0, PARAM_INT);
1484       *      $PAGE->set_url('/course/view.php', array('id' => $id));
1485       *
1486       * @param moodle_url|string $url URL relative to $CFG->wwwroot or {@link moodle_url} instance
1487       * @param array $params parameters to add to the URL
1488       * @throws coding_exception
1489       */
1490      public function set_url($url, array $params = null) {
1491          global $CFG;
1492  
1493          if (is_string($url) && strpos($url, 'http') !== 0) {
1494              if (strpos($url, '/') === 0) {
1495                  // Add the wwwroot to the relative url.
1496                  $url = $CFG->wwwroot . $url;
1497              } else {
1498                  throw new coding_exception('Invalid parameter $url, has to be full url or in shortened form starting with /.');
1499              }
1500          }
1501  
1502          $this->_url = new moodle_url($url, $params);
1503  
1504          $fullurl = $this->_url->out_omit_querystring();
1505          if (strpos($fullurl, "$CFG->wwwroot/") !== 0) {
1506              debugging('Most probably incorrect set_page() url argument, it does not match the wwwroot!');
1507          }
1508          $shorturl = str_replace("$CFG->wwwroot/", '', $fullurl);
1509  
1510          if (is_null($this->_pagetype)) {
1511              $this->initialise_default_pagetype($shorturl);
1512          }
1513      }
1514  
1515      /**
1516       * Make sure page URL does not contain the given URL parameter.
1517       *
1518       * This should not be necessary if the script has called set_url properly.
1519       * However, in some situations like the block editing actions; when the URL
1520       * has been guessed, it will contain dangerous block-related actions.
1521       * Therefore, the blocks code calls this function to clean up such parameters
1522       * before doing any redirect.
1523       *
1524       * @param string $param the name of the parameter to make sure is not in the
1525       * page URL.
1526       */
1527      public function ensure_param_not_in_url($param) {
1528          $this->_url->remove_params($param);
1529      }
1530  
1531      /**
1532       * Sets an alternative version of this page.
1533       *
1534       * There can be alternate versions of some pages (for example an RSS feed version).
1535       * Call this method for each alternative version available.
1536       * For each alternative version a link will be included in the <head> tag.
1537       *
1538       * @param string $title The title to give the alternate version.
1539       * @param string|moodle_url $url The URL of the alternate version.
1540       * @param string $mimetype The mime-type of the alternate version.
1541       * @throws coding_exception
1542       */
1543      public function add_alternate_version($title, $url, $mimetype) {
1544          if ($this->_state > self::STATE_BEFORE_HEADER) {
1545              throw new coding_exception('Cannot call moodle_page::add_alternate_version after output has been started.');
1546          }
1547          $alt = new stdClass;
1548          $alt->title = $title;
1549          $alt->url = $url;
1550          $this->_alternateversions[$mimetype] = $alt;
1551      }
1552  
1553      /**
1554       * Specify a form control should be focused when the page has loaded.
1555       *
1556       * @param string $controlid the id of the HTML element to be focused.
1557       */
1558      public function set_focuscontrol($controlid) {
1559          $this->_focuscontrol = $controlid;
1560      }
1561  
1562      /**
1563       * Specify a fragment of HTML that goes where the 'Turn editing on' button normally goes.
1564       *
1565       * @param string $html the HTML to display there.
1566       */
1567      public function set_button($html) {
1568          $this->_button = $html;
1569      }
1570  
1571      /**
1572       * Set the capability that allows users to edit blocks on this page.
1573       *
1574       * Normally the default of 'moodle/site:manageblocks' is used, but a few
1575       * pages like the My Moodle page need to use a different capability
1576       * like 'moodle/my:manageblocks'.
1577       *
1578       * @param string $capability a capability.
1579       */
1580      public function set_blocks_editing_capability($capability) {
1581          $this->_blockseditingcap = $capability;
1582      }
1583  
1584      /**
1585       * Some pages let you turn editing on for reasons other than editing blocks.
1586       * If that is the case, you can pass other capabilities that let the user
1587       * edit this page here.
1588       *
1589       * @param string|array $capability either a capability, or an array of capabilities.
1590       */
1591      public function set_other_editing_capability($capability) {
1592          if (is_array($capability)) {
1593              $this->_othereditingcaps = array_unique($this->_othereditingcaps + $capability);
1594          } else {
1595              $this->_othereditingcaps[] = $capability;
1596          }
1597      }
1598  
1599      /**
1600       * Sets whether the browser should cache this page or not.
1601       *
1602       * @param bool $cacheable can this page be cached by the user's browser.
1603       */
1604      public function set_cacheable($cacheable) {
1605          $this->_cacheable = $cacheable;
1606      }
1607  
1608      /**
1609       * Sets the page to periodically refresh
1610       *
1611       * This function must be called before $OUTPUT->header has been called or
1612       * a coding exception will be thrown.
1613       *
1614       * @param int $delay Sets the delay before refreshing the page, if set to null refresh is cancelled.
1615       * @throws coding_exception
1616       */
1617      public function set_periodic_refresh_delay($delay = null) {
1618          if ($this->_state > self::STATE_BEFORE_HEADER) {
1619              throw new coding_exception('You cannot set a periodic refresh delay after the header has been printed');
1620          }
1621          if ($delay === null) {
1622              $this->_periodicrefreshdelay = null;
1623          } else if (is_int($delay)) {
1624              $this->_periodicrefreshdelay = $delay;
1625          }
1626      }
1627  
1628      /**
1629       * Force this page to use a particular theme.
1630       *
1631       * Please use this cautiously.
1632       * It is only intended to be used by the themes selector admin page.
1633       *
1634       * @param string $themename the name of the theme to use.
1635       */
1636      public function force_theme($themename) {
1637          $this->ensure_theme_not_set();
1638          $this->_theme = theme_config::load($themename);
1639      }
1640  
1641      /**
1642       * Reload theme settings.
1643       *
1644       * This is used when we need to reset settings
1645       * because they are now double cached in theme.
1646       */
1647      public function reload_theme() {
1648          if (!is_null($this->_theme)) {
1649              $this->_theme = theme_config::load($this->_theme->name);
1650          }
1651      }
1652  
1653      /**
1654       * Remove access to editing/moving on all blocks on a page.
1655       * This overrides any capabilities and is intended only for pages where no user (including admins) should be able to
1656       * modify blocks on the page (eg My Courses).
1657       *
1658       * @return void
1659       */
1660      public function force_lock_all_blocks(): void {
1661          $this->_forcelockallblocks = true;
1662      }
1663  
1664      /**
1665       * @deprecated since Moodle 3.4
1666       */
1667      public function https_required() {
1668          throw new coding_exception('https_required() cannot be used anymore.');
1669      }
1670  
1671      /**
1672       * @deprecated since Moodle 3.4
1673       */
1674      public function verify_https_required() {
1675          throw new coding_exception('verify_https_required() cannot be used anymore.');
1676      }
1677  
1678      /**
1679       * Allows to 'serialize' the edited page information and store it in the session cache
1680       *
1681       * Due to Moodle architectural decision and non-SPA approach, a lot of page setup is
1682       * happening in the actual page php file, for example, setting course/cm/context,
1683       * setting layout and pagetype, requiring capabilities, setting specific block editing
1684       * capabilities.
1685       *
1686       * When storing this information in the session cache we can pass the pagehash (cache key)
1687       * as an argument to web services in AJAX requests and retrieve all data associated with
1688       * the page without actually executing PHP code on that page.
1689       *
1690       * @return string|null
1691       */
1692      public function get_edited_page_hash(): ?string {
1693          global $SESSION;
1694          if (!$this->user_is_editing()) {
1695              return null;
1696          }
1697          $url = new moodle_url($this->url);
1698          $url->set_anchor(null);
1699          $data = [
1700              'contextid' => $this->context->id,
1701              'url' => $url->out_as_local_url(false),
1702          ];
1703          if (($cm = $this->cm) && $cm->id) {
1704              $data['cmid'] = $cm->id;
1705          } else if (($course = $this->course) && $course->id) {
1706              $data['courseid'] = $course->id;
1707          }
1708          $keys = ['pagelayout', 'pagetype', 'subpage'];
1709          foreach ($keys as $key) {
1710              if ("{$this->$key}" !== "") {
1711                  $data[$key] = $this->$key;
1712              }
1713          }
1714          if ($this->_blockseditingcap !== 'moodle/site:manageblocks') {
1715              $data['bcap'] = $this->_blockseditingcap;
1716          }
1717          if (!empty($this->_othereditingcaps)) {
1718              $data['caps'] = $this->_othereditingcaps;
1719          }
1720          if ($this->_forcelockallblocks) {
1721              $data['forcelock'] = true;
1722          }
1723          $hash = md5(json_encode($data + ['sesskey' => sesskey()]));
1724          $SESSION->editedpages = ($SESSION->editedpages ?? []);
1725          $SESSION->editedpages[$hash] = $data;
1726          return $hash;
1727      }
1728  
1729      /**
1730       * Retrieves a page that is being edited from the session cache
1731       *
1732       * {@see self::get_edited_page_hash()}
1733       *
1734       * @param string $hash
1735       * @param int $strictness
1736       * @return self|null
1737       */
1738      public static function retrieve_edited_page(string $hash, $strictness = IGNORE_MISSING): ?self {
1739          global $CFG, $SESSION;
1740          $data = $SESSION->editedpages[$hash] ?? null;
1741          if (!$data || !is_array($data)
1742                  || $hash !== md5(json_encode($data + ['sesskey' => sesskey()]))) {
1743              // This can happen if the session cache becomes corrupt or the user logged out and back
1744              // in in another window and changed their session. Refreshing the page will generate
1745              // and store the correct page hash.
1746              if ($strictness === MUST_EXIST) {
1747                  throw new moodle_exception('editedpagenotfound');
1748              }
1749              return null;
1750          }
1751  
1752          if (!empty($CFG->moodlepageclass)) {
1753              if (!empty($CFG->moodlepageclassfile)) {
1754                  require_once($CFG->moodlepageclassfile);
1755              }
1756              $classname = $CFG->moodlepageclass;
1757          } else {
1758              $classname = self::class;
1759          }
1760          /** @var moodle_page $page */
1761          $page = new $classname();
1762          $page->set_context(context::instance_by_id($data['contextid']));
1763          if (array_key_exists('cmid', $data)) {
1764              [$course, $cm] = get_course_and_cm_from_cmid($data['cmid']);
1765              $page->set_cm($cm, $course);
1766          } else if (array_key_exists('courseid', $data)) {
1767              $page->set_course(get_course($data['courseid']));
1768          }
1769          $page->set_url(new moodle_url($data['url']));
1770          $keys = ['pagelayout', 'pagetype', 'subpage'];
1771          foreach ($keys as $key) {
1772              if (array_key_exists($key, $data)) {
1773                  $func = "set_{$key}";
1774                  $page->$func($data[$key]);
1775              }
1776          }
1777          if (array_key_exists('bcap', $data)) {
1778              $page->set_blocks_editing_capability($data['bcap']);
1779          }
1780          if (array_key_exists('caps', $data)) {
1781              foreach ($data['caps'] as $cap) {
1782                  $page->set_other_editing_capability($cap);
1783              }
1784          }
1785          if (array_key_exists('forcelock', $data)) {
1786              $page->force_lock_all_blocks();
1787          }
1788          $page->blocks->add_custom_regions_for_pagetype($page->pagetype);
1789          return $page;
1790      }
1791  
1792      // Initialisation methods =====================================================
1793      // These set various things up in a default way.
1794  
1795      /**
1796       * This method is called when the page first moves out of the STATE_BEFORE_HEADER
1797       * state. This is our last change to initialise things.
1798       */
1799      protected function starting_output() {
1800          global $CFG;
1801  
1802          if (!during_initial_install()) {
1803              $this->blocks->load_blocks();
1804              if (empty($this->_block_actions_done)) {
1805                  $this->_block_actions_done = true;
1806                  if ($this->blocks->process_url_actions($this)) {
1807                      redirect($this->url->out(false));
1808                  }
1809              }
1810              $this->blocks->create_all_block_instances();
1811          }
1812  
1813          // If maintenance mode is on, change the page header.
1814          if (!empty($CFG->maintenance_enabled)) {
1815              $this->set_button('<a href="' . $CFG->wwwroot . '/' . $CFG->admin .
1816                      '/settings.php?section=maintenancemode">' . get_string('maintenancemode', 'admin') .
1817                      '</a> ' . $this->button);
1818  
1819              $this->set_title(get_string('maintenancemode', 'admin'));
1820          }
1821  
1822          $this->initialise_standard_body_classes();
1823      }
1824  
1825      /**
1826       * Method for use by Moodle core to set up the theme. Do not
1827       * use this in your own code.
1828       *
1829       * Make sure the right theme for this page is loaded. Tell our
1830       * blocks_manager about the theme block regions, and then, if
1831       * we are $PAGE, set up the global $OUTPUT.
1832       *
1833       * @return void
1834       */
1835      public function initialise_theme_and_output() {
1836          global $OUTPUT, $PAGE, $SITE, $CFG;
1837  
1838          if (!empty($this->_wherethemewasinitialised)) {
1839              return;
1840          }
1841  
1842          if (!during_initial_install()) {
1843              // Detect PAGE->context mess.
1844              $this->magic_get_context();
1845          }
1846  
1847          if (!$this->_course && !during_initial_install()) {
1848              $this->set_course($SITE);
1849          }
1850  
1851          if (is_null($this->_theme)) {
1852              $themename = $this->resolve_theme();
1853              $this->_theme = theme_config::load($themename);
1854          }
1855  
1856          $this->_theme->setup_blocks($this->pagelayout, $this->blocks);
1857  
1858          if ($this === $PAGE) {
1859              $target = null;
1860              if ($this->pagelayout === 'maintenance') {
1861                  // If the page is using the maintenance layout then we're going to force target to maintenance.
1862                  // This leads to a special core renderer that is designed to block access to API's that are likely unavailable for this
1863                  // page layout.
1864                  $target = RENDERER_TARGET_MAINTENANCE;
1865              }
1866              $OUTPUT = $this->get_renderer('core', null, $target);
1867          }
1868  
1869          if (!during_initial_install()) {
1870              $filtermanager = filter_manager::instance();
1871              $filtermanager->setup_page_for_globally_available_filters($this);
1872          }
1873  
1874          $this->_wherethemewasinitialised = debug_backtrace();
1875      }
1876  
1877      /**
1878       * For diagnostic/debugging purposes, find where the theme setup was triggered.
1879       *
1880       * @return null|array null if theme not yet setup. Stacktrace if it was.
1881       */
1882      public function get_where_theme_was_initialised() {
1883          return $this->_wherethemewasinitialised;
1884      }
1885  
1886      /**
1887       * Reset the theme and output for a new context. This only makes sense from
1888       * external::validate_context(). Do not cheat.
1889       *
1890       * @return string the name of the theme that should be used on this page.
1891       */
1892      public function reset_theme_and_output() {
1893          global $COURSE, $SITE;
1894  
1895          $COURSE = clone($SITE);
1896          $this->_theme = null;
1897          $this->_wherethemewasinitialised = null;
1898          $this->_course = null;
1899          $this->_cm = null;
1900          $this->_module = null;
1901          $this->_context = null;
1902      }
1903  
1904      /**
1905       * Work out the theme this page should use.
1906       *
1907       * This depends on numerous $CFG settings, and the properties of this page.
1908       *
1909       * @return string the name of the theme that should be used on this page.
1910       */
1911      protected function resolve_theme() {
1912          global $CFG, $USER, $SESSION;
1913  
1914          if (empty($CFG->themeorder)) {
1915              $themeorder = array('course', 'category', 'session', 'user', 'cohort', 'site');
1916          } else {
1917              $themeorder = $CFG->themeorder;
1918              // Just in case, make sure we always use the site theme if nothing else matched.
1919              $themeorder[] = 'site';
1920          }
1921  
1922          $mnetpeertheme = '';
1923          $mnetvarsok = isset($CFG->mnet_localhost_id) && isset($USER->mnethostid);
1924          if (isloggedin() and $mnetvarsok and $USER->mnethostid != $CFG->mnet_localhost_id) {
1925              require_once($CFG->dirroot.'/mnet/peer.php');
1926              $mnetpeer = new mnet_peer();
1927              $mnetpeer->set_id($USER->mnethostid);
1928              if ($mnetpeer->force_theme == 1 && $mnetpeer->theme != '') {
1929                  $mnetpeertheme = $mnetpeer->theme;
1930              }
1931          }
1932  
1933          foreach ($themeorder as $themetype) {
1934  
1935              switch ($themetype) {
1936                  case 'course':
1937                      if (!empty($CFG->allowcoursethemes) && !empty($this->_course->theme)) {
1938                          return $this->_course->theme;
1939                      }
1940                  break;
1941  
1942                  case 'category':
1943                      if (!empty($CFG->allowcategorythemes) && !empty($this->_course)) {
1944                          $categories = $this->categories;
1945                          foreach ($categories as $category) {
1946                              if (!empty($category->theme)) {
1947                                  return $category->theme;
1948                              }
1949                          }
1950                      }
1951                  break;
1952  
1953                  case 'session':
1954                      if (!empty($SESSION->theme)) {
1955                          return $SESSION->theme;
1956                      }
1957                  break;
1958  
1959                  case 'user':
1960                      if (!empty($CFG->allowuserthemes) && !empty($USER->theme)) {
1961                          if ($mnetpeertheme) {
1962                              return $mnetpeertheme;
1963                          } else {
1964                              return $USER->theme;
1965                          }
1966                      }
1967                  break;
1968  
1969                  case 'cohort':
1970                      if (!empty($CFG->allowcohortthemes) && !empty($USER->cohorttheme)) {
1971                          return $USER->cohorttheme;
1972                      }
1973                  break;
1974  
1975                  case 'site':
1976                      if ($mnetpeertheme) {
1977                          return $mnetpeertheme;
1978                      }
1979  
1980                      // Use theme if it is set in config.
1981                      if (!empty($CFG->theme)) {
1982                          return $CFG->theme;
1983                      }
1984                      // Use the overall default theme.
1985                      return theme_config::DEFAULT_THEME;
1986              }
1987          }
1988  
1989          // We should most certainly have resolved a theme by now. Something has gone wrong.
1990          debugging('Error resolving the theme to use for this page.', DEBUG_DEVELOPER);
1991          return theme_config::DEFAULT_THEME;
1992      }
1993  
1994  
1995      /**
1996       * Sets ->pagetype from the script name. For example, if the script that was
1997       * run is mod/quiz/view.php, ->pagetype will be set to 'mod-quiz-view'.
1998       *
1999       * @param string $script the path to the script that should be used to
2000       * initialise ->pagetype. If not passed the $SCRIPT global will be used.
2001       * If legacy code has set $CFG->pagepath that will be used instead, and a
2002       * developer warning issued.
2003       */
2004      protected function initialise_default_pagetype($script = null) {
2005          global $CFG, $SCRIPT;
2006  
2007          if (isset($CFG->pagepath)) {
2008              debugging('Some code appears to have set $CFG->pagepath. That was a horrible deprecated thing. ' .
2009                      'Don\'t do it! Try calling $PAGE->set_pagetype() instead.');
2010              $script = $CFG->pagepath;
2011              unset($CFG->pagepath);
2012          }
2013  
2014          if (is_null($script)) {
2015              $script = ltrim($SCRIPT ?? '', '/');
2016              $len = strlen($CFG->admin);
2017              if (substr($script, 0, $len) == $CFG->admin) {
2018                  $script = 'admin' . substr($script, $len);
2019              }
2020          }
2021  
2022          $path = str_replace('.php', '', $script);
2023          if (substr($path, -1) == '/') {
2024              $path .= 'index';
2025          }
2026  
2027          if (empty($path) || $path == 'index') {
2028              $this->_pagetype = 'site-index';
2029          } else {
2030              $this->_pagetype = str_replace('/', '-', $path);
2031          }
2032      }
2033  
2034      /**
2035       * Initialises the CSS classes that will be added to body tag of the page.
2036       *
2037       * The function is responsible for adding all of the critical CSS classes
2038       * that describe the current page, and its state.
2039       * This includes classes that describe the following for example:
2040       *    - Current language
2041       *    - Language direction
2042       *    - YUI CSS initialisation
2043       *    - Pagelayout
2044       * These are commonly used in CSS to target specific types of pages.
2045       */
2046      protected function initialise_standard_body_classes() {
2047          global $CFG, $USER;
2048  
2049          $pagetype = $this->pagetype;
2050          if ($pagetype == 'site-index') {
2051              $this->_legacyclass = 'course';
2052          } else if (substr($pagetype, 0, 6) == 'admin-') {
2053              $this->_legacyclass = 'admin';
2054          }
2055          $this->add_body_class($this->_legacyclass);
2056  
2057          $pathbits = explode('-', trim($pagetype));
2058          for ($i = 1; $i < count($pathbits); $i++) {
2059              $this->add_body_class('path-' . join('-', array_slice($pathbits, 0, $i)));
2060          }
2061  
2062          $this->add_body_classes(core_useragent::get_browser_version_classes());
2063          $this->add_body_class('dir-' . get_string('thisdirection', 'langconfig'));
2064          $this->add_body_class('lang-' . current_language());
2065          $this->add_body_class('yui-skin-sam'); // Make YUI happy, if it is used.
2066          $this->add_body_class('yui3-skin-sam'); // Make YUI3 happy, if it is used.
2067          $this->add_body_class($this->url_to_class_name($CFG->wwwroot));
2068  
2069          // Extra class describing current page layout.
2070          $this->add_body_class('pagelayout-' . $this->_pagelayout);
2071  
2072          if (!during_initial_install()) {
2073              $this->add_body_class('course-' . $this->_course->id);
2074              $this->add_body_class('context-' . $this->_context->id);
2075          }
2076  
2077          if (!empty($this->_cm)) {
2078              $this->add_body_class('cmid-' . $this->_cm->id);
2079              $this->add_body_class('cm-type-' . $this->_cm->modname);
2080          }
2081  
2082          if (!empty($CFG->allowcategorythemes) && !empty($this->_course)) {
2083              $this->ensure_category_loaded();
2084              foreach ($this->_categories as $catid => $notused) {
2085                  $this->add_body_class('category-' . $catid);
2086              }
2087          } else {
2088              $catid = 0;
2089              if (is_array($this->_categories)) {
2090                  $catids = array_keys($this->_categories);
2091                  $catid = reset($catids);
2092              } else if (!empty($this->_course->category)) {
2093                  $catid = $this->_course->category;
2094              }
2095              if ($catid) {
2096                  $this->add_body_class('category-' . $catid);
2097              }
2098          }
2099  
2100          if (!isloggedin()) {
2101              $this->add_body_class('notloggedin');
2102          }
2103  
2104          if ($this->user_is_editing()) {
2105              $this->add_body_class('editing');
2106              if (optional_param('bui_moveid', false, PARAM_INT)) {
2107                  $this->add_body_class('blocks-moving');
2108              }
2109          }
2110  
2111          if (!empty($CFG->blocksdrag)) {
2112              $this->add_body_class('drag');
2113          }
2114  
2115          if ($this->_devicetypeinuse != 'default') {
2116              $this->add_body_class($this->_devicetypeinuse . 'theme');
2117          }
2118  
2119          // Add class for behat site to apply behat related fixes.
2120          if (defined('BEHAT_SITE_RUNNING')) {
2121              $this->add_body_class('behat-site');
2122          }
2123      }
2124  
2125      /**
2126       * Loads the activity record for the current CM object associated with this
2127       * page.
2128       *
2129       * This will load {@link moodle_page::$_module} with a row from the related
2130       * module table in the database.
2131       * For instance if {@link moodle_page::$_cm} is a forum then a row from the
2132       * forum table will be loaded.
2133       */
2134      protected function load_activity_record() {
2135          global $DB;
2136          if (is_null($this->_cm)) {
2137              return;
2138          }
2139          $this->_module = $DB->get_record($this->_cm->modname, array('id' => $this->_cm->instance));
2140      }
2141  
2142      /**
2143       * This function ensures that the category of the current course has been
2144       * loaded, and if not, the function loads it now.
2145       *
2146       * @return void
2147       * @throws coding_exception
2148       */
2149      protected function ensure_category_loaded() {
2150          if (is_array($this->_categories)) {
2151              return; // Already done.
2152          }
2153          if (is_null($this->_course)) {
2154              throw new coding_exception('Attempt to get the course category for this page before the course was set.');
2155          }
2156          if ($this->_course->category == 0) {
2157              $this->_categories = array();
2158          } else {
2159              $this->load_category($this->_course->category);
2160          }
2161      }
2162  
2163      /**
2164       * Loads the requested category into the pages categories array.
2165       *
2166       * @param int $categoryid
2167       * @throws moodle_exception
2168       */
2169      protected function load_category($categoryid) {
2170          global $DB;
2171          $category = $DB->get_record('course_categories', array('id' => $categoryid));
2172          if (!$category) {
2173              throw new moodle_exception('unknowncategory');
2174          }
2175          $this->_categories[$category->id] = $category;
2176          $parentcategoryids = explode('/', trim($category->path, '/'));
2177          array_pop($parentcategoryids);
2178          foreach (array_reverse($parentcategoryids) as $catid) {
2179              $this->_categories[$catid] = null;
2180          }
2181      }
2182  
2183      /**
2184       * Ensures that the category the current course is within, as well as all of
2185       * its parent categories, have been loaded.
2186       *
2187       * @return void
2188       */
2189      protected function ensure_categories_loaded() {
2190          global $DB;
2191          $this->ensure_category_loaded();
2192          if (!is_null(end($this->_categories))) {
2193              return; // Already done.
2194          }
2195          $idstoload = array_keys($this->_categories);
2196          array_shift($idstoload);
2197          $categories = $DB->get_records_list('course_categories', 'id', $idstoload);
2198          foreach ($idstoload as $catid) {
2199              $this->_categories[$catid] = $categories[$catid];
2200          }
2201      }
2202  
2203      /**
2204       * Ensure the theme has not been loaded yet. If it has an exception is thrown.
2205       *
2206       * @throws coding_exception
2207       */
2208      protected function ensure_theme_not_set() {
2209          // This is explicitly allowed for webservices though which may process many course contexts in a single request.
2210          if (WS_SERVER) {
2211              return;
2212          }
2213  
2214          if (!is_null($this->_theme)) {
2215              throw new coding_exception('The theme has already been set up for this page ready for output. ' .
2216                      'Therefore, you can no longer change the theme, or anything that might affect what ' .
2217                      'the current theme is, for example, the course.',
2218                      'Stack trace when the theme was set up: ' . format_backtrace($this->_wherethemewasinitialised));
2219          }
2220      }
2221  
2222      /**
2223       * Converts the provided URL into a CSS class that be used within the page.
2224       * This is primarily used to add the wwwroot to the body tag as a CSS class.
2225       *
2226       * @param string $url
2227       * @return string
2228       */
2229      protected function url_to_class_name($url) {
2230          $bits = parse_url($url);
2231          $class = str_replace('.', '-', $bits['host']);
2232          if (!empty($bits['port'])) {
2233              $class .= '--' . $bits['port'];
2234          }
2235          if (!empty($bits['path'])) {
2236              $path = trim($bits['path'], '/');
2237              if ($path) {
2238                  $class .= '--' . str_replace('/', '-', $path);
2239              }
2240          }
2241          return $class;
2242      }
2243  
2244      /**
2245       * Combines all of the required editing caps for the page and returns them
2246       * as an array.
2247       *
2248       * @return array
2249       */
2250      protected function all_editing_caps() {
2251          $caps = $this->_othereditingcaps;
2252          $caps[] = $this->_blockseditingcap;
2253          return $caps;
2254      }
2255  
2256      /**
2257       * Returns true if the page URL has beem set.
2258       *
2259       * @return bool
2260       */
2261      public function has_set_url() {
2262          return ($this->_url!==null);
2263      }
2264  
2265      /**
2266       * Gets set when the block actions for the page have been processed.
2267       *
2268       * @param bool $setting
2269       */
2270      public function set_block_actions_done($setting = true) {
2271          $this->_block_actions_done = $setting;
2272      }
2273  
2274      /**
2275       * Are popup notifications allowed on this page?
2276       * Popup notifications may be disallowed in situations such as while upgrading or completing a quiz
2277       *
2278       * @return bool true if popup notifications may be displayed
2279       */
2280      public function get_popup_notification_allowed() {
2281          return $this->_popup_notification_allowed;
2282      }
2283  
2284      /**
2285       * Allow or disallow popup notifications on this page. Popups are allowed by default.
2286       *
2287       * @param bool $allowed true if notifications are allowed. False if not allowed. They are allowed by default.
2288       */
2289      public function set_popup_notification_allowed($allowed) {
2290          $this->_popup_notification_allowed = $allowed;
2291      }
2292  
2293      /**
2294       * Returns the block region having made any required theme manipulations.
2295       *
2296       * @since Moodle 2.5.1 2.6
2297       * @param string $region
2298       * @return string
2299       */
2300      public function apply_theme_region_manipulations($region) {
2301          if ($this->blockmanipulations && isset($this->blockmanipulations[$region])) {
2302              $regionwas = $region;
2303              $regionnow = $this->blockmanipulations[$region];
2304              if ($this->blocks->is_known_region($regionwas) && $this->blocks->is_known_region($regionnow)) {
2305                  // Both the before and after regions are known so we can swap them over.
2306                  return $regionnow;
2307              }
2308              // We didn't know about both, we won't swap them over.
2309              return $regionwas;
2310          }
2311          return $region;
2312      }
2313  
2314      /**
2315       * Add a report node and a specific report to the navigation.
2316       *
2317       * @param int $userid The user ID that we are looking to add this report node to.
2318       * @param array $nodeinfo Name and url of the final node that we are creating.
2319       */
2320      public function add_report_nodes($userid, $nodeinfo) {
2321          global $USER;
2322          // Try to find the specific user node.
2323          $newusernode = $this->navigation->find('user' . $userid, null);
2324          $reportnode = null;
2325          $navigationnodeerror =
2326                  'Could not find the navigation node requested. Please check that the node you are looking for exists.';
2327          if ($userid != $USER->id  || $this->context->contextlevel == CONTEXT_COURSE) {
2328              // Within a course context we need to properly indicate how we have come to the page,
2329              // regardless of whether it's currently logged in user or not.
2330              // Check that we have a valid node.
2331              if (empty($newusernode)) {
2332                  // Throw an error if we ever reach here.
2333                  throw new coding_exception($navigationnodeerror);
2334              }
2335              // Add 'Reports' to the user node.
2336              $reportnode = $newusernode->add(get_string('reports'));
2337          } else {
2338              // We are looking at our own profile.
2339              $myprofilenode = $this->settingsnav->find('myprofile', null);
2340              // Check that we do end up with a valid node.
2341              if (empty($myprofilenode)) {
2342                  // Throw an error if we ever reach here.
2343                  throw new coding_exception($navigationnodeerror);
2344              }
2345              // Add 'Reports' to our node.
2346              $reportnode = $myprofilenode->add(get_string('reports'));
2347          }
2348          // Finally add the report to the navigation tree.
2349          $reportnode->add($nodeinfo['name'], $nodeinfo['url'], navigation_node::TYPE_CUSTOM, null, null,
2350              new pix_icon('i/report', $nodeinfo['name']));
2351      }
2352  
2353      /**
2354       * Add some HTML to the list of actions to render in the header actions menu.
2355       *
2356       * @param string $html The HTML to add.
2357       */
2358      public function add_header_action(string $html) : void {
2359          $this->_headeractions[] = $html;
2360      }
2361  
2362      /**
2363       * Get the list of HTML for actions to render in the header actions menu.
2364       *
2365       * @return string[]
2366       */
2367      public function get_header_actions() : array {
2368          return $this->_headeractions;
2369      }
2370  
2371      /**
2372       * Set the flag to indicate if the region main settings should be rendered as an action
2373       * in the header actions menu rather than at the top of the content.
2374       *
2375       * @param bool $value If the settings should be in the header.
2376       */
2377      public function set_include_region_main_settings_in_header_actions(bool $value) : void {
2378          $this->_regionmainsettingsinheader = $value;
2379      }
2380  
2381      /**
2382       * Check if the  region main settings should be rendered as an action in the header actions
2383       * menu rather than at the top of the content.
2384       *
2385       * @return bool
2386       */
2387      public function include_region_main_settings_in_header_actions() : bool {
2388          return $this->_regionmainsettingsinheader;
2389      }
2390  
2391      /**
2392       * Set the flag to indicate if the secondary navigation should be rendered.
2393       *
2394       * @param bool $hassecondarynavigation If the secondary navigation should be rendered.
2395       * @param bool $istablist When true, the navigation bar should be rendered and behave with a tablist ARIA role.
2396       *                        If false, it's rendered with a menubar ARIA role. Defaults to false.
2397       */
2398      public function set_secondary_navigation(bool $hassecondarynavigation, bool $istablist = false): void {
2399          $this->_hassecondarynavigation = $hassecondarynavigation;
2400          $this->_hastablistsecondarynavigation = $istablist;
2401      }
2402  
2403      /**
2404       * Check if the secondary navigation should be rendered.
2405       *
2406       * @return bool
2407       */
2408      public function has_secondary_navigation(): bool {
2409          return $this->_hassecondarynavigation;
2410      }
2411  
2412      /**
2413       * Check if the secondary navigation should be rendered with a tablist as opposed to a menubar.
2414       *
2415       * @return bool
2416       */
2417      public function has_tablist_secondary_navigation(): bool {
2418          return $this->_hastablistsecondarynavigation;
2419      }
2420  
2421      /**
2422       * Set the key of the secondary nav node to be activated.
2423       *
2424       * @param string $navkey the key of the secondary nav node to be activated.
2425       */
2426      public function set_secondary_active_tab(string $navkey) : void {
2427          $this->_activekeysecondary = $navkey;
2428      }
2429  
2430      /**
2431       * The key of secondary nav node to activate.
2432       *
2433       * @return string|null get the key of the secondary node to activate.
2434       */
2435      public function get_secondary_active_tab(): ?string {
2436          return $this->_activekeysecondary;
2437      }
2438  
2439      /**
2440       * Set the key of the primary nav node to be activated.
2441       *
2442       * @param string $navkey
2443       */
2444      public function set_primary_active_tab(string $navkey): void {
2445          $this->_activenodeprimary = $navkey;
2446      }
2447  
2448      /**
2449       * The key of the primary nav node to activate.
2450       *
2451       * @return string|null get the key of the primary nav node to activate.
2452       */
2453      public function get_primary_activate_tab(): ?string {
2454          return $this->_activenodeprimary;
2455      }
2456  
2457      /**
2458       * Sets the navigation overflow state. This allows developers to turn off the overflow menu if they perhaps are using
2459       * some other navigation to show settings.
2460       *
2461       * @param bool  $state  The state of whether to show the navigation overflow.
2462       */
2463      public function set_navigation_overflow_state(bool $state): void {
2464          $this->_navigationoverflow = $state;
2465      }
2466  
2467      /**
2468       * Gets the navigation overflow state.
2469       *
2470       * @return bool The navigation overflow state.
2471       */
2472      public function get_navigation_overflow_state(): bool {
2473          return $this->_navigationoverflow;
2474      }
2475  }