lib/navigationlib.php

   1 <?php
   2
   3 // This file is part of Moodle - http://moodle.org/
   4 //
   5 // Moodle is free software: you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation, either version 3 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // Moodle is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License
  16 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  17
  18 /**
  19  * This file contains classes used to manage the navigation structures in Moodle
  20  * and was introduced as part of the changes occuring in Moodle 2.0
  21  *
  22  * @since      2.0
  23  * @package    core
  24  * @copyright  2009 Sam Hemelryk
  25  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  26  */
  27
  28 defined('MOODLE_INTERNAL') || die();
  29
  30 /**
  31  * The name that will be used to separate the navigation cache within SESSION
  32  */
  33 define('NAVIGATION_CACHE_NAME', 'navigation');
  34
  35 /**
  36  * This class is used to represent a node in a navigation tree
  37  *
  38  * This class is used to represent a node in a navigation tree within Moodle,
  39  * the tree could be one of global navigation, settings navigation, or the navbar.
  40  * Each node can be one of two types either a Leaf (default) or a branch.
  41  * When a node is first created it is created as a leaf, when/if children are added
  42  * the node then becomes a branch.
  43  *
  44  * @package   core
  45  * @category  navigation
  46  * @copyright 2009 Sam Hemelryk
  47  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  48  */
  49 class navigation_node implements renderable {
  50     /** @var int Used to identify this node a leaf (default) 0 */
  51     const NODETYPE_LEAF =   0;
  52     /** @var int Used to identify this node a branch, happens with children  1 */
  53     const NODETYPE_BRANCH = 1;
  54     /** @var null Unknown node type null */
  55     const TYPE_UNKNOWN =    null;
  56     /** @var int System node type 0 */
  57     const TYPE_ROOTNODE =   0;
  58     /** @var int System node type 1 */
  59     const TYPE_SYSTEM =     1;
  60     /** @var int Category node type 10 */
  61     const TYPE_CATEGORY =   10;
  62     /** @var int Course node type 20 */
  63     const TYPE_COURSE =     20;
  64     /** @var int Course Structure node type 30 */
  65     const TYPE_SECTION =    30;
  66     /** @var int Activity node type, e.g. Forum, Quiz 40 */
  67     const TYPE_ACTIVITY =   40;
  68     /** @var int Resource node type, e.g. Link to a file, or label 50 */
  69     const TYPE_RESOURCE =   50;
  70     /** @var int A custom node type, default when adding without specifing type 60 */
  71     const TYPE_CUSTOM =     60;
  72     /** @var int Setting node type, used only within settings nav 70 */
  73     const TYPE_SETTING =    70;
  74     /** @var int Setting node type, used only within settings nav 80 */
  75     const TYPE_USER =       80;
  76     /** @var int Setting node type, used for containers of no importance 90 */
  77     const TYPE_CONTAINER =  90;
  78
  79     /** @var int Parameter to aid the coder in tracking [optional] */
  80     public $id = null;
  81     /** @var string|int The identifier for the node, used to retrieve the node */
  82     public $key = null;
  83     /** @var string The text to use for the node */
  84     public $text = null;
  85     /** @var string Short text to use if requested [optional] */
  86     public $shorttext = null;
  87     /** @var string The title attribute for an action if one is defined */
  88     public $title = null;
  89     /** @var string A string that can be used to build a help button */
  90     public $helpbutton = null;
  91     /** @var moodle_url|action_link|null An action for the node (link) */
  92     public $action = null;
  93     /** @var pix_icon The path to an icon to use for this node */
  94     public $icon = null;
  95     /** @var int See TYPE_* constants defined for this class */
  96     public $type = self::TYPE_UNKNOWN;
  97     /** @var int See NODETYPE_* constants defined for this class */
  98     public $nodetype = self::NODETYPE_LEAF;
  99     /** @var bool If set to true the node will be collapsed by default */
 100     public $collapse = false;
 101     /** @var bool If set to true the node will be expanded by default */
 102     public $forceopen = false;
 103     /** @var array An array of CSS classes for the node */
 104     public $classes = array();
 105     /** @var navigation_node_collection An array of child nodes */
 106     public $children = array();
 107     /** @var bool If set to true the node will be recognised as active */
 108     public $isactive = false;
 109     /** @var bool If set to true the node will be dimmed */
 110     public $hidden = false;
 111     /** @var bool If set to false the node will not be displayed */
 112     public $display = true;
 113     /** @var bool If set to true then an HR will be printed before the node */
 114     public $preceedwithhr = false;
 115     /** @var bool If set to true the the navigation bar should ignore this node */
 116     public $mainnavonly = false;
 117     /** @var bool If set to true a title will be added to the action no matter what */
 118     public $forcetitle = false;
 119     /** @var navigation_node A reference to the node parent, you should never set this directly you should always call set_parent */
 120     public $parent = null;
 121     /** @var bool Override to not display the icon even if one is provided **/
 122     public $hideicon = false;
 123     /** @var array */
 124     protected $namedtypes = array(0=>'system',10=>'category',20=>'course',30=>'structure',40=>'activity',50=>'resource',60=>'custom',70=>'setting', 80=>'user');
 125     /** @var moodle_url */
 126     protected static $fullmeurl = null;
 127     /** @var bool toogles auto matching of active node */
 128     public static $autofindactive = true;
 129     /** @var mixed If set to an int, that section will be included even if it has no activities */
 130     public $includesectionnum = false;
 131
 132     /**
 133      * Constructs a new navigation_node
 134      *
 135      * @param array|string $properties Either an array of properties or a string to use
 136      *                     as the text for the node
 137      */
 138     public function __construct($properties) {
 139         if (is_array($properties)) {
 140             // Check the array for each property that we allow to set at construction.
 141             // text         - The main content for the node
 142             // shorttext    - A short text if required for the node
 143             // icon         - The icon to display for the node
 144             // type         - The type of the node
 145             // key          - The key to use to identify the node
 146             // parent       - A reference to the nodes parent
 147             // action       - The action to attribute to this node, usually a URL to link to
 148             if (array_key_exists('text', $properties)) {
 149                 $this->text = $properties['text'];
 150             }
 151             if (array_key_exists('shorttext', $properties)) {
 152                 $this->shorttext = $properties['shorttext'];
 153             }
 154             if (!array_key_exists('icon', $properties)) {
 155                 $properties['icon'] = new pix_icon('i/navigationitem', 'moodle');
 156             }
 157             $this->icon = $properties['icon'];
 158             if ($this->icon instanceof pix_icon) {
 159                 if (empty($this->icon->attributes['class'])) {
 160                     $this->icon->attributes['class'] = 'navicon';
 161                 } else {
 162                     $this->icon->attributes['class'] .= ' navicon';
 163                 }
 164             }
 165             if (array_key_exists('type', $properties)) {
 166                 $this->type = $properties['type'];
 167             } else {
 168                 $this->type = self::TYPE_CUSTOM;
 169             }
 170             if (array_key_exists('key', $properties)) {
 171                 $this->key = $properties['key'];
 172             }
 173             // This needs to happen last because of the check_if_active call that occurs
 174             if (array_key_exists('action', $properties)) {
 175                 $this->action = $properties['action'];
 176                 if (is_string($this->action)) {
 177                     $this->action = new moodle_url($this->action);
 178                 }
 179                 if (self::$autofindactive) {
 180                     $this->check_if_active();
 181                 }
 182             }
 183             if (array_key_exists('parent', $properties)) {
 184                 $this->set_parent($properties['parent']);
 185             }
 186         } else if (is_string($properties)) {
 187             $this->text = $properties;
 188         }
 189         if ($this->text === null) {
 190             throw new coding_exception('You must set the text for the node when you create it.');
 191         }
 192         // Default the title to the text
 193         $this->title = $this->text;
 194         // Instantiate a new navigation node collection for this nodes children
 195         $this->children = new navigation_node_collection();
 196     }
 197
 198     /**
 199      * Checks if this node is the active node.
 200      *
 201      * This is determined by comparing the action for the node against the
 202      * defined URL for the page. A match will see this node marked as active.
 203      *
 204      * @param int $strength One of URL_MATCH_EXACT, URL_MATCH_PARAMS, or URL_MATCH_BASE
 205      * @return bool
 206      */
 207     public function check_if_active($strength=URL_MATCH_EXACT) {
 208         global $FULLME, $PAGE;
 209         // Set fullmeurl if it hasn't already been set
 210         if (self::$fullmeurl == null) {
 211             if ($PAGE->has_set_url()) {
 212                 self::override_active_url(new moodle_url($PAGE->url));
 213             } else {
 214                 self::override_active_url(new moodle_url($FULLME));
 215             }
 216         }
 217
 218         // Compare the action of this node against the fullmeurl
 219         if ($this->action instanceof moodle_url && $this->action->compare(self::$fullmeurl, $strength)) {
 220             $this->make_active();
 221             return true;
 222         }
 223         return false;
 224     }
 225
 226     /**
 227      * This sets the URL that the URL of new nodes get compared to when locating
 228      * the active node.
 229      *
 230      * The active node is the node that matches the URL set here. By default this
 231      * is either $PAGE->url or if that hasn't been set $FULLME.
 232      *
 233      * @param moodle_url $url The url to use for the fullmeurl.
 234      */
 235     public static function override_active_url(moodle_url $url) {
 236         // Clone the URL, in case the calling script changes their URL later.
 237         self::$fullmeurl = new moodle_url($url);
 238     }
 239
 240     /**
 241      * Creates a navigation node, ready to add it as a child using add_node
 242      * function. (The created node needs to be added before you can use it.)
 243      * @param string $text
 244      * @param moodle_url|action_link $action
 245      * @param int $type
 246      * @param string $shorttext
 247      * @param string|int $key
 248      * @param pix_icon $icon
 249      * @return navigation_node
 250      */
 251     public static function create($text, $action=null, $type=self::TYPE_CUSTOM,
 252             $shorttext=null, $key=null, pix_icon $icon=null) {
 253         // Properties array used when creating the new navigation node
 254         $itemarray = array(
 255             'text' => $text,
 256             'type' => $type
 257         );
 258         // Set the action if one was provided
 259         if ($action!==null) {
 260             $itemarray['action'] = $action;
 261         }
 262         // Set the shorttext if one was provided
 263         if ($shorttext!==null) {
 264             $itemarray['shorttext'] = $shorttext;
 265         }
 266         // Set the icon if one was provided
 267         if ($icon!==null) {
 268             $itemarray['icon'] = $icon;
 269         }
 270         // Set the key
 271         $itemarray['key'] = $key;
 272         // Construct and return
 273         return new navigation_node($itemarray);
 274     }
 275
 276     /**
 277      * Adds a navigation node as a child of this node.
 278      *
 279      * @param string $text
 280      * @param moodle_url|action_link $action
 281      * @param int $type
 282      * @param string $shorttext
 283      * @param string|int $key
 284      * @param pix_icon $icon
 285      * @return navigation_node
 286      */
 287     public function add($text, $action=null, $type=self::TYPE_CUSTOM, $shorttext=null, $key=null, pix_icon $icon=null) {
 288         // Create child node
 289         $childnode = self::create($text, $action, $type, $shorttext, $key, $icon);
 290
 291         // Add the child to end and return
 292         return $this->add_node($childnode);
 293     }
 294
 295     /**
 296      * Adds a navigation node as a child of this one, given a $node object
 297      * created using the create function.
 298      * @param navigation_node $childnode Node to add
 299      * @param string $beforekey
 300      * @return navigation_node The added node
 301      */
 302     public function add_node(navigation_node $childnode, $beforekey=null) {
 303         // First convert the nodetype for this node to a branch as it will now have children
 304         if ($this->nodetype !== self::NODETYPE_BRANCH) {
 305             $this->nodetype = self::NODETYPE_BRANCH;
 306         }
 307         // Set the parent to this node
 308         $childnode->set_parent($this);
 309
 310         // Default the key to the number of children if not provided
 311         if ($childnode->key === null) {
 312             $childnode->key = $this->children->count();
 313         }
 314
 315         // Add the child using the navigation_node_collections add method
 316         $node = $this->children->add($childnode, $beforekey);
 317
 318         // If added node is a category node or the user is logged in and it's a course
 319         // then mark added node as a branch (makes it expandable by AJAX)
 320         $type = $childnode->type;
 321         if (($type==self::TYPE_CATEGORY) || (isloggedin() && $type==self::TYPE_COURSE)) {
 322             $node->nodetype = self::NODETYPE_BRANCH;
 323         }
 324         // If this node is hidden mark it's children as hidden also
 325         if ($this->hidden) {
 326             $node->hidden = true;
 327         }
 328         // Return added node (reference returned by $this->children->add()
 329         return $node;
 330     }
 331
 332     /**
 333      * Return a list of all the keys of all the child nodes.
 334      * @return array the keys.
 335      */
 336     public function get_children_key_list() {
 337         return $this->children->get_key_list();
 338     }
 339
 340     /**
 341      * Searches for a node of the given type with the given key.
 342      *
 343      * This searches this node plus all of its children, and their children....
 344      * If you know the node you are looking for is a child of this node then please
 345      * use the get method instead.
 346      *
 347      * @param int|string $key The key of the node we are looking for
 348      * @param int $type One of navigation_node::TYPE_*
 349      * @return navigation_node|false
 350      */
 351     public function find($key, $type) {
 352         return $this->children->find($key, $type);
 353     }
 354
 355     /**
 356      * Get the child of this node that has the given key + (optional) type.
 357      *
 358      * If you are looking for a node and want to search all children + thier children
 359      * then please use the find method instead.
 360      *
 361      * @param int|string $key The key of the node we are looking for
 362      * @param int $type One of navigation_node::TYPE_*
 363      * @return navigation_node|false
 364      */
 365     public function get($key, $type=null) {
 366         return $this->children->get($key, $type);
 367     }
 368
 369     /**
 370      * Removes this node.
 371      *
 372      * @return bool
 373      */
 374     public function remove() {
 375         return $this->parent->children->remove($this->key, $this->type);
 376     }
 377
 378     /**
 379      * Checks if this node has or could have any children
 380      *
 381      * @return bool Returns true if it has children or could have (by AJAX expansion)
 382      */
 383     public function has_children() {
 384         return ($this->nodetype === navigation_node::NODETYPE_BRANCH || $this->children->count()>0);
 385     }
 386
 387     /**
 388      * Marks this node as active and forces it open.
 389      *
 390      * Important: If you are here because you need to mark a node active to get
 391      * the navigation to do what you want have you looked at {@link navigation_node::override_active_url()}?
 392      * You can use it to specify a different URL to match the active navigation node on
 393      * rather than having to locate and manually mark a node active.
 394      */
 395     public function make_active() {
 396         $this->isactive = true;
 397         $this->add_class('active_tree_node');
 398         $this->force_open();
 399         if ($this->parent !== null) {
 400             $this->parent->make_inactive();
 401         }
 402     }
 403
 404     /**
 405      * Marks a node as inactive and recusised back to the base of the tree
 406      * doing the same to all parents.
 407      */
 408     public function make_inactive() {
 409         $this->isactive = false;
 410         $this->remove_class('active_tree_node');
 411         if ($this->parent !== null) {
 412             $this->parent->make_inactive();
 413         }
 414     }
 415
 416     /**
 417      * Forces this node to be open and at the same time forces open all
 418      * parents until the root node.
 419      *
 420      * Recursive.
 421      */
 422     public function force_open() {
 423         $this->forceopen = true;
 424         if ($this->parent !== null) {
 425             $this->parent->force_open();
 426         }
 427     }
 428
 429     /**
 430      * Adds a CSS class to this node.
 431      *
 432      * @param string $class
 433      * @return bool
 434      */
 435     public function add_class($class) {
 436         if (!in_array($class, $this->classes)) {
 437             $this->classes[] = $class;
 438         }
 439         return true;
 440     }
 441
 442     /**
 443      * Removes a CSS class from this node.
 444      *
 445      * @param string $class
 446      * @return bool True if the class was successfully removed.
 447      */
 448     public function remove_class($class) {
 449         if (in_array($class, $this->classes)) {
 450             $key = array_search($class,$this->classes);
 451             if ($key!==false) {
 452                 unset($this->classes[$key]);
 453                 return true;
 454             }
 455         }
 456         return false;
 457     }
 458
 459     /**
 460      * Sets the title for this node and forces Moodle to utilise it.
 461      * @param string $title
 462      */
 463     public function title($title) {
 464         $this->title = $title;
 465         $this->forcetitle = true;
 466     }
 467
 468     /**
 469      * Resets the page specific information on this node if it is being unserialised.
 470      */
 471     public function __wakeup(){
 472         $this->forceopen = false;
 473         $this->isactive = false;
 474         $this->remove_class('active_tree_node');
 475     }
 476
 477     /**
 478      * Checks if this node or any of its children contain the active node.
 479      *
 480      * Recursive.
 481      *
 482      * @return bool
 483      */
 484     public function contains_active_node() {
 485         if ($this->isactive) {
 486             return true;
 487         } else {
 488             foreach ($this->children as $child) {
 489                 if ($child->isactive || $child->contains_active_node()) {
 490                     return true;
 491                 }
 492             }
 493         }
 494         return false;
 495     }
 496
 497     /**
 498      * Finds the active node.
 499      *
 500      * Searches this nodes children plus all of the children for the active node
 501      * and returns it if found.
 502      *
 503      * Recursive.
 504      *
 505      * @return navigation_node|false
 506      */
 507     public function find_active_node() {
 508         if ($this->isactive) {
 509             return $this;
 510         } else {
 511             foreach ($this->children as &$child) {
 512                 $outcome = $child->find_active_node();
 513                 if ($outcome !== false) {
 514                     return $outcome;
 515                 }
 516             }
 517         }
 518         return false;
 519     }
 520
 521     /**
 522      * Searches all children for the best matching active node
 523      * @return navigation_node|false
 524      */
 525     public function search_for_active_node() {
 526         if ($this->check_if_active(URL_MATCH_BASE)) {
 527             return $this;
 528         } else {
 529             foreach ($this->children as &$child) {
 530                 $outcome = $child->search_for_active_node();
 531                 if ($outcome !== false) {
 532                     return $outcome;
 533                 }
 534             }
 535         }
 536         return false;
 537     }
 538
 539     /**
 540      * Gets the content for this node.
 541      *
 542      * @param bool $shorttext If true shorttext is used rather than the normal text
 543      * @return string
 544      */
 545     public function get_content($shorttext=false) {
 546         if ($shorttext && $this->shorttext!==null) {
 547             return format_string($this->shorttext);
 548         } else {
 549             return format_string($this->text);
 550         }
 551     }
 552
 553     /**
 554      * Gets the title to use for this node.
 555      *
 556      * @return string
 557      */
 558     public function get_title() {
 559         if ($this->forcetitle || $this->action != null){
 560             return $this->title;
 561         } else {
 562             return '';
 563         }
 564     }
 565
 566     /**
 567      * Gets the CSS class to add to this node to describe its type
 568      *
 569      * @return string
 570      */
 571     public function get_css_type() {
 572         if (array_key_exists($this->type, $this->namedtypes)) {
 573             return 'type_'.$this->namedtypes[$this->type];
 574         }
 575         return 'type_unknown';
 576     }
 577
 578     /**
 579      * Finds all nodes that are expandable by AJAX
 580      *
 581      * @param array $expandable An array by reference to populate with expandable nodes.
 582      */
 583     public function find_expandable(array &$expandable) {
 584         foreach ($this->children as &$child) {
 585             if ($child->nodetype == self::NODETYPE_BRANCH && $child->children->count() == 0 && $child->display) {
 586                 $child->id = 'expandable_branch_'.(count($expandable)+1);
 587                 $this->add_class('canexpand');
 588                 $expandable[] = array('id' => $child->id, 'key' => $child->key, 'type' => $child->type);
 589             }
 590             $child->find_expandable($expandable);
 591         }
 592     }
 593
 594     /**
 595      * Finds all nodes of a given type (recursive)
 596      *
 597      * @param int $type One of navigation_node::TYPE_*
 598      * @return array
 599      */
 600     public function find_all_of_type($type) {
 601         $nodes = $this->children->type($type);
 602         foreach ($this->children as &$node) {
 603             $childnodes = $node->find_all_of_type($type);
 604             $nodes = array_merge($nodes, $childnodes);
 605         }
 606         return $nodes;
 607     }
 608
 609     /**
 610      * Removes this node if it is empty
 611      */
 612     public function trim_if_empty() {
 613         if ($this->children->count() == 0) {
 614             $this->remove();
 615         }
 616     }
 617
 618     /**
 619      * Creates a tab representation of this nodes children that can be used
 620      * with print_tabs to produce the tabs on a page.
 621      *
 622      * call_user_func_array('print_tabs', $node->get_tabs_array());
 623      *
 624      * @param array $inactive
 625      * @param bool $return
 626      * @return array Array (tabs, selected, inactive, activated, return)
 627      */
 628     public function get_tabs_array(array $inactive=array(), $return=false) {
 629         $tabs = array();
 630         $rows = array();
 631         $selected = null;
 632         $activated = array();
 633         foreach ($this->children as $node) {
 634             $tabs[] = new tabobject($node->key, $node->action, $node->get_content(), $node->get_title());
 635             if ($node->contains_active_node()) {
 636                 if ($node->children->count() > 0) {
 637                     $activated[] = $node->key;
 638                     foreach ($node->children as $child) {
 639                         if ($child->contains_active_node()) {
 640                             $selected = $child->key;
 641                         }
 642                         $rows[] = new tabobject($child->key, $child->action, $child->get_content(), $child->get_title());
 643                     }
 644                 } else {
 645                     $selected = $node->key;
 646                 }
 647             }
 648         }
 649         return array(array($tabs, $rows), $selected, $inactive, $activated, $return);
 650     }
 651
 652     /**
 653      * Sets the parent for this node and if this node is active ensures that the tree is properly
 654      * adjusted as well.
 655      *
 656      * @param navigation_node $parent
 657      */
 658     public function set_parent(navigation_node $parent) {
 659         // Set the parent (thats the easy part)
 660         $this->parent = $parent;
 661         // Check if this node is active (this is checked during construction)
 662         if ($this->isactive) {
 663             // Force all of the parent nodes open so you can see this node
 664             $this->parent->force_open();
 665             // Make all parents inactive so that its clear where we are.
 666             $this->parent->make_inactive();
 667         }
 668     }
 669 }
 670
 671 /**
 672  * Navigation node collection
 673  *
 674  * This class is responsible for managing a collection of navigation nodes.
 675  * It is required because a node's unique identifier is a combination of both its
 676  * key and its type.
 677  *
 678  * Originally an array was used with a string key that was a combination of the two
 679  * however it was decided that a better solution would be to use a class that
 680  * implements the standard IteratorAggregate interface.
 681  *
 682  * @package   core
 683  * @category  navigation
 684  * @copyright 2010 Sam Hemelryk
 685  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 686  */
 687 class navigation_node_collection implements IteratorAggregate {
 688     /**
 689      * A multidimensional array to where the first key is the type and the second
 690      * key is the nodes key.
 691      * @var array
 692      */
 693     protected $collection = array();
 694     /**
 695      * An array that contains references to nodes in the same order they were added.
 696      * This is maintained as a progressive array.
 697      * @var array
 698      */
 699     protected $orderedcollection = array();
 700     /**
 701      * A reference to the last node that was added to the collection
 702      * @var navigation_node
 703      */
 704     protected $last = null;
 705     /**
 706      * The total number of items added to this array.
 707      * @var int
 708      */
 709     protected $count = 0;
 710
 711     /**
 712      * Adds a navigation node to the collection
 713      *
 714      * @param navigation_node $node Node to add
 715      * @param string $beforekey If specified, adds before a node with this key,
 716      *   otherwise adds at end
 717      * @return navigation_node Added node
 718      */
 719     public function add(navigation_node $node, $beforekey=null) {
 720         global $CFG;
 721         $key = $node->key;
 722         $type = $node->type;
 723
 724         // First check we have a 2nd dimension for this type
 725         if (!array_key_exists($type, $this->orderedcollection)) {
 726             $this->orderedcollection[$type] = array();
 727         }
 728         // Check for a collision and report if debugging is turned on
 729         if ($CFG->debug && array_key_exists($key, $this->orderedcollection[$type])) {
 730             debugging('Navigation node intersect: Adding a node that already exists '.$key, DEBUG_DEVELOPER);
 731         }
 732
 733         // Find the key to add before
 734         $newindex = $this->count;
 735         $last = true;
 736         if ($beforekey !== null) {
 737             foreach ($this->collection as $index => $othernode) {
 738                 if ($othernode->key === $beforekey) {
 739                     $newindex = $index;
 740                     $last = false;
 741                     break;
 742                 }
 743             }
 744             if ($newindex === $this->count) {
 745                 debugging('Navigation node add_before: Reference node not found ' . $beforekey .
 746                         ', options: ' . implode(' ', $this->get_key_list()), DEBUG_DEVELOPER);
 747             }
 748         }
 749
 750         // Add the node to the appropriate place in the by-type structure (which
 751         // is not ordered, despite the variable name)
 752         $this->orderedcollection[$type][$key] = $node;
 753         if (!$last) {
 754             // Update existing references in the ordered collection (which is the
 755             // one that isn't called 'ordered') to shuffle them along if required
 756             for ($oldindex = $this->count; $oldindex > $newindex; $oldindex--) {
 757                 $this->collection[$oldindex] = $this->collection[$oldindex - 1];
 758             }
 759         }
 760         // Add a reference to the node to the progressive collection.
 761         $this->collection[$newindex] = &$this->orderedcollection[$type][$key];
 762         // Update the last property to a reference to this new node.
 763         $this->last = &$this->orderedcollection[$type][$key];
 764
 765         // Reorder the array by index if needed
 766         if (!$last) {
 767             ksort($this->collection);
 768         }
 769         $this->count++;
 770         // Return the reference to the now added node
 771         return $node;
 772     }
 773
 774     /**
 775      * Return a list of all the keys of all the nodes.
 776      * @return array the keys.
 777      */
 778     public function get_key_list() {
 779         $keys = array();
 780         foreach ($this->collection as $node) {
 781             $keys[] = $node->key;
 782         }
 783         return $keys;
 784     }
 785
 786     /**
 787      * Fetches a node from this collection.
 788      *
 789      * @param string|int $key The key of the node we want to find.
 790      * @param int $type One of navigation_node::TYPE_*.
 791      * @return navigation_node|null
 792      */
 793     public function get($key, $type=null) {
 794         if ($type !== null) {
 795             // If the type is known then we can simply check and fetch
 796             if (!empty($this->orderedcollection[$type][$key])) {
 797                 return $this->orderedcollection[$type][$key];
 798             }
 799         } else {
 800             // Because we don't know the type we look in the progressive array
 801             foreach ($this->collection as $node) {
 802                 if ($node->key === $key) {
 803                     return $node;
 804                 }
 805             }
 806         }
 807         return false;
 808     }
 809
 810     /**
 811      * Searches for a node with matching key and type.
 812      *
 813      * This function searches both the nodes in this collection and all of
 814      * the nodes in each collection belonging to the nodes in this collection.
 815      *
 816      * Recursive.
 817      *
 818      * @param string|int $key  The key of the node we want to find.
 819      * @param int $type  One of navigation_node::TYPE_*.
 820      * @return navigation_node|null
 821      */
 822     public function find($key, $type=null) {
 823         if ($type !== null && array_key_exists($type, $this->orderedcollection) && array_key_exists($key, $this->orderedcollection[$type])) {
 824             return $this->orderedcollection[$type][$key];
 825         } else {
 826             $nodes = $this->getIterator();
 827             // Search immediate children first
 828             foreach ($nodes as &$node) {
 829                 if ($node->key === $key && ($type === null || $type === $node->type)) {
 830                     return $node;
 831                 }
 832             }
 833             // Now search each childs children
 834             foreach ($nodes as &$node) {
 835                 $result = $node->children->find($key, $type);
 836                 if ($result !== false) {
 837                     return $result;
 838                 }
 839             }
 840         }
 841         return false;
 842     }
 843
 844     /**
 845      * Fetches the last node that was added to this collection
 846      *
 847      * @return navigation_node
 848      */
 849     public function last() {
 850         return $this->last;
 851     }
 852
 853     /**
 854      * Fetches all nodes of a given type from this collection
 855      *
 856      * @param string|int $type  node type being searched for.
 857      * @return array ordered collection
 858      */
 859     public function type($type) {
 860         if (!array_key_exists($type, $this->orderedcollection)) {
 861             $this->orderedcollection[$type] = array();
 862         }
 863         return $this->orderedcollection[$type];
 864     }
 865     /**
 866      * Removes the node with the given key and type from the collection
 867      *
 868      * @param string|int $key The key of the node we want to find.
 869      * @param int $type
 870      * @return bool
 871      */
 872     public function remove($key, $type=null) {
 873         $child = $this->get($key, $type);
 874         if ($child !== false) {
 875             foreach ($this->collection as $colkey => $node) {
 876                 if ($node->key == $key && $node->type == $type) {
 877                     unset($this->collection[$colkey]);
 878                     break;
 879                 }
 880             }
 881             unset($this->orderedcollection[$child->type][$child->key]);
 882             $this->count--;
 883             return true;
 884         }
 885         return false;
 886     }
 887
 888     /**
 889      * Gets the number of nodes in this collection
 890      *
 891      * This option uses an internal count rather than counting the actual options to avoid
 892      * a performance hit through the count function.
 893      *
 894      * @return int
 895      */
 896     public function count() {
 897         return $this->count;
 898     }
 899     /**
 900      * Gets an array iterator for the collection.
 901      *
 902      * This is required by the IteratorAggregator interface and is used by routines
 903      * such as the foreach loop.
 904      *
 905      * @return ArrayIterator
 906      */
 907     public function getIterator() {
 908         return new ArrayIterator($this->collection);
 909     }
 910 }
 911
 912 /**
 913  * The global navigation class used for... the global navigation
 914  *
 915  * This class is used by PAGE to store the global navigation for the site
 916  * and is then used by the settings nav and navbar to save on processing and DB calls
 917  *
 918  * See
 919  * {@link lib/pagelib.php} {@link moodle_page::initialise_theme_and_output()}
 920  * {@link lib/ajax/getnavbranch.php} Called by ajax
 921  *
 922  * @package   core
 923  * @category  navigation
 924  * @copyright 2009 Sam Hemelryk
 925  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 926  */
 927 class global_navigation extends navigation_node {
 928     /** @var moodle_page The Moodle page this navigation object belongs to. */
 929     protected $page;
 930     /** @var bool switch to let us know if the navigation object is initialised*/
 931     protected $initialised = false;
 932     /** @var array An array of course information */
 933     protected $mycourses = array();
 934     /** @var array An array for containing  root navigation nodes */
 935     protected $rootnodes = array();
 936     /** @var bool A switch for whether to show empty sections in the navigation */
 937     protected $showemptysections = false;
 938     /** @var bool A switch for whether courses should be shown within categories on the navigation. */
 939     protected $showcategories = null;
 940     /** @var array An array of stdClasses for users that the navigation is extended for */
 941     protected $extendforuser = array();
 942     /** @var navigation_cache */
 943     protected $cache;
 944     /** @var array An array of course ids that are present in the navigation */
 945     protected $addedcourses = array();
 946     /** @var array An array of category ids that are included in the navigation */
 947     protected $addedcategories = array();
 948     /** @var int expansion limit */
 949     protected $expansionlimit = 0;
 950     /** @var int userid to allow parent to see child's profile page navigation */
 951     protected $useridtouseforparentchecks = 0;
 952
 953     /**
 954      * Constructs a new global navigation
 955      *
 956      * @param moodle_page $page The page this navigation object belongs to
 957      */
 958     public function __construct(moodle_page $page) {
 959         global $CFG, $SITE, $USER;
 960
 961         if (during_initial_install()) {
 962             return;
 963         }
 964
 965         if (get_home_page() == HOMEPAGE_SITE) {
 966             // We are using the site home for the root element
 967             $properties = array(
 968                 'key' => 'home',
 969                 'type' => navigation_node::TYPE_SYSTEM,
 970                 'text' => get_string('home'),
 971                 'action' => new moodle_url('/')
 972             );
 973         } else {
 974             // We are using the users my moodle for the root element
 975             $properties = array(
 976                 'key' => 'myhome',
 977                 'type' => navigation_node::TYPE_SYSTEM,
 978                 'text' => get_string('myhome'),
 979                 'action' => new moodle_url('/my/')
 980             );
 981         }
 982
 983         // Use the parents constructor.... good good reuse
 984         parent::__construct($properties);
 985
 986         // Initalise and set defaults
 987         $this->page = $page;
 988         $this->forceopen = true;
 989         $this->cache = new navigation_cache(NAVIGATION_CACHE_NAME);
 990     }
 991
 992     /**
 993      * Mutator to set userid to allow parent to see child's profile
 994      * page navigation. See MDL-25805 for initial issue. Linked to it
 995      * is an issue explaining why this is a REALLY UGLY HACK thats not
 996      * for you to use!
 997      *
 998      * @param int $userid userid of profile page that parent wants to navigate around.
 999      */
1000     public function set_userid_for_parent_checks($userid) {
1001         $this->useridtouseforparentchecks = $userid;
1002     }
1003
1004
1005     /**
1006      * Initialises the navigation object.
1007      *
1008      * This causes the navigation object to look at the current state of the page
1009      * that it is associated with and then load the appropriate content.
1010      *
1011      * This should only occur the first time that the navigation structure is utilised
1012      * which will normally be either when the navbar is called to be displayed or
1013      * when a block makes use of it.
1014      *
1015      * @return bool
1016      */
1017     public function initialise() {
1018         global $CFG, $SITE, $USER, $DB;
1019         // Check if it has alread been initialised
1020         if ($this->initialised || during_initial_install()) {
1021             return true;
1022         }
1023         $this->initialised = true;
1024
1025         // Set up the five base root nodes. These are nodes where we will put our
1026         // content and are as follows:
1027         // site:        Navigation for the front page.
1028         // myprofile:     User profile information goes here.
1029         // mycourses:   The users courses get added here.
1030         // courses:     Additional courses are added here.
1031         // users:       Other users information loaded here.
1032         $this->rootnodes = array();
1033         if (get_home_page() == HOMEPAGE_SITE) {
1034             // The home element should be my moodle because the root element is the site
1035             if (isloggedin() && !isguestuser()) {  // Makes no sense if you aren't logged in
1036                 $this->rootnodes['home'] = $this->add(get_string('myhome'), new moodle_url('/my/'), self::TYPE_SETTING, null, 'home');
1037             }
1038         } else {
1039             // The home element should be the site because the root node is my moodle
1040             $this->rootnodes['home'] = $this->add(get_string('sitehome'), new moodle_url('/'), self::TYPE_SETTING, null, 'home');
1041             if (!empty($CFG->defaulthomepage) && ($CFG->defaulthomepage == HOMEPAGE_MY)) {
1042                 // We need to stop automatic redirection
1043                 $this->rootnodes['home']->action->param('redirect', '0');
1044             }
1045         }
1046         $this->rootnodes['site']      = $this->add_course($SITE);
1047         $this->rootnodes['myprofile'] = $this->add(get_string('myprofile'), null, self::TYPE_USER, null, 'myprofile');
1048         $this->rootnodes['mycourses'] = $this->add(get_string('mycourses'), null, self::TYPE_ROOTNODE, null, 'mycourses');
1049         $this->rootnodes['courses']   = $this->add(get_string('courses'), new moodle_url('/course/index.php'), self::TYPE_ROOTNODE, null, 'courses');
1050         $this->rootnodes['users']     = $this->add(get_string('users'), null, self::TYPE_ROOTNODE, null, 'users');
1051
1052         // Fetch all of the users courses.
1053         $limit = 20;
1054         if (!empty($CFG->navcourselimit)) {
1055             $limit = $CFG->navcourselimit;
1056         }
1057
1058         $mycourses = enrol_get_my_courses(NULL, 'visible DESC,sortorder ASC');
1059         $showallcourses = (count($mycourses) == 0 || !empty($CFG->navshowallcourses));
1060         // When checking if we are to show categories there is an additional override.
1061         // If the user is viewing a category then we will load it regardless of settings.
1062         // to ensure that the navigation is consistent.
1063         $showcategories = $this->page->context->contextlevel == CONTEXT_COURSECAT || ($showallcourses && $this->show_categories());
1064         $issite = ($this->page->course->id == SITEID);
1065         $ismycourse = (array_key_exists($this->page->course->id, $mycourses));
1066
1067         // Check if any courses were returned.
1068         if (count($mycourses) > 0) {
1069
1070             // Check if categories should be displayed within the my courses branch
1071             if (!empty($CFG->navshowmycoursecategories)) {
1072
1073                 // Find the category of each mycourse
1074                 $categories = array();
1075                 foreach ($mycourses as $course) {
1076                     $categories[] = $course->category;
1077                 }
1078
1079                 // Do a single DB query to get the categories immediately associated with
1080                 // courses the user is enrolled in.
1081                 $categories = $DB->get_records_list('course_categories', 'id', array_unique($categories), 'depth ASC, sortorder ASC');
1082                 // Work out the parent categories that we need to load that we havn't
1083                 // already got.
1084                 $categoryids = array();
1085                 foreach ($categories as $category) {
1086                     $categoryids = array_merge($categoryids, explode('/', trim($category->path, '/')));
1087                 }
1088                 $categoryids = array_unique($categoryids);
1089                 $categoryids = array_diff($categoryids, array_keys($categories));
1090
1091                 if (count($categoryids)) {
1092                     // Fetch any other categories we need.
1093                     $allcategories = $DB->get_records_list('course_categories', 'id', $categoryids, 'depth ASC, sortorder ASC');
1094                     if (is_array($allcategories) && count($allcategories) > 0) {
1095                         $categories = array_merge($categories, $allcategories);
1096                     }
1097                 }
1098
1099                 // We ONLY want the categories, we need to get rid of the keys
1100                 $categories = array_values($categories);
1101                 $addedcategories = array();
1102                 while (($category = array_shift($categories)) !== null) {
1103                     if ($category->parent == '0') {
1104                         $categoryparent = $this->rootnodes['mycourses'];
1105                     } else if (array_key_exists($category->parent, $addedcategories)) {
1106                         $categoryparent = $addedcategories[$category->parent];
1107                     } else {
1108                         // Prepare to count iterations. We don't want to loop forever
1109                         // accidentally if for some reason a category can't be placed.
1110                         if (!isset($category->loopcount)) {
1111                             $category->loopcount = 0;
1112                         }
1113                         $category->loopcount++;
1114                         if ($category->loopcount > 5) {
1115                             // This is a pretty serious problem and this should never happen.
1116                             // If it does then for some reason a category has been loaded but
1117                             // its parents have now. It could be data corruption.
1118                             debugging('Category '.$category->id.' could not be placed within the navigation', DEBUG_DEVELOPER);
1119                         } else {
1120                             // Add it back to the end of the categories array
1121                             array_push($categories, $category);
1122                         }
1123                         continue;
1124                     }
1125
1126                     $url = new moodle_url('/course/category.php', array('id' => $category->id));
1127                     $addedcategories[$category->id] = $categoryparent->add($category->name, $url, self::TYPE_CATEGORY, $category->name, $category->id);
1128
1129                     if (!$category->visible) {
1130                         if (!has_capability('moodle/category:viewhiddencategories', get_context_instance(CONTEXT_COURSECAT, $category->parent))) {
1131                             $addedcategories[$category->id]->display = false;
1132                         } else {
1133                             $addedcategories[$category->id]->hidden = true;
1134                         }
1135                     }
1136                 }
1137             }
1138
1139             // Add all of the users courses to the navigation.
1140             foreach ($mycourses as $course) {
1141                 $course->coursenode = $this->add_course($course, false, true);
1142             }
1143         }
1144
1145         if ($showallcourses) {
1146             // Load all courses
1147             $this->load_all_courses();
1148         }
1149
1150         // We always load the frontpage course to ensure it is available without
1151         // JavaScript enabled.
1152         $frontpagecourse = $this->load_course($SITE);
1153         $this->add_front_page_course_essentials($frontpagecourse, $SITE);
1154         $this->load_course_sections($SITE, $frontpagecourse);
1155
1156         $canviewcourseprofile = true;
1157
1158         // Next load context specific content into the navigation
1159         switch ($this->page->context->contextlevel) {
1160             case CONTEXT_SYSTEM :
1161                 // This has already been loaded we just need to map the variable
1162                 $coursenode = $frontpagecourse;
1163                 $this->load_all_categories(null, $showcategories);
1164                 break;
1165             case CONTEXT_COURSECAT :
1166                 // This has already been loaded we just need to map the variable
1167                 $coursenode = $frontpagecourse;
1168                 $this->load_all_categories($this->page->context->instanceid, $showcategories);
1169                 if (array_key_exists($this->page->context->instanceid, $this->addedcategories)) {
1170                     $this->addedcategories[$this->page->context->instanceid]->make_active();
1171                 }
1172                 break;
1173             case CONTEXT_BLOCK :
1174             case CONTEXT_COURSE :
1175                 if ($issite) {
1176                     // If it is the front page course, or a block on it then
1177                     // everything has already been loaded.
1178                     break;
1179                 }
1180                 // Load the course associated with the page into the navigation
1181                 $course = $this->page->course;
1182                 if ($showcategories && !$ismycourse) {
1183                     $this->load_all_categories($course->category, $showcategories);
1184                 }
1185                 $coursenode = $this->load_course($course);
1186
1187                 // If the course wasn't added then don't try going any further.
1188                 if (!$coursenode) {
1189                     $canviewcourseprofile = false;
1190                     break;
1191                 }
1192
1193                 // If the user is not enrolled then we only want to show the
1194                 // course node and not populate it.
1195
1196                 // Not enrolled, can't view, and hasn't switched roles
1197                 if (!can_access_course($course)) {
1198                     // TODO: very ugly hack - do not force "parents" to enrol into course their child is enrolled in,
1199                     // this hack has been propagated from user/view.php to display the navigation node. (MDL-25805)
1200                     $isparent = false;
1201                     if ($this->useridtouseforparentchecks) {
1202                         if ($this->useridtouseforparentchecks != $USER->id) {
1203                             $usercontext   = get_context_instance(CONTEXT_USER, $this->useridtouseforparentchecks, MUST_EXIST);
1204                             if ($DB->record_exists('role_assignments', array('userid' => $USER->id, 'contextid' => $usercontext->id))
1205                                     and has_capability('moodle/user:viewdetails', $usercontext)) {
1206                                 $isparent = true;
1207                             }
1208                         }
1209                     }
1210
1211                     if (!$isparent) {
1212                         $coursenode->make_active();
1213                         $canviewcourseprofile = false;
1214                         break;
1215                     }
1216                 }
1217                 // Add the essentials such as reports etc...
1218                 $this->add_course_essentials($coursenode, $course);
1219                 if ($this->format_display_course_content($course->format)) {
1220                     // Load the course sections
1221                     $sections = $this->load_course_sections($course, $coursenode);
1222                 }
1223                 if (!$coursenode->contains_active_node() && !$coursenode->search_for_active_node()) {
1224                     $coursenode->make_active();
1225                 }
1226                 break;
1227             case CONTEXT_MODULE :
1228                 if ($issite) {
1229                     // If this is the site course then most information will have
1230                     // already been loaded.
1231                     // However we need to check if there is more content that can
1232                     // yet be loaded for the specific module instance.
1233                     $activitynode = $this->rootnodes['site']->get($this->page->cm->id, navigation_node::TYPE_ACTIVITY);
1234                     if ($activitynode) {
1235                         $this->load_activity($this->page->cm, $this->page->course, $activitynode);
1236                     }
1237                     break;
1238                 }
1239
1240                 $course = $this->page->course;
1241                 $cm = $this->page->cm;
1242
1243                 if ($showcategories && !$ismycourse) {
1244                     $this->load_all_categories($course->category, $showcategories);
1245                 }
1246
1247                 // Load the course associated with the page into the navigation
1248                 $coursenode = $this->load_course($course);
1249
1250                 // If the course wasn't added then don't try going any further.
1251                 if (!$coursenode) {
1252                     $canviewcourseprofile = false;
1253                     break;
1254                 }
1255
1256                 // If the user is not enrolled then we only want to show the
1257                 // course node and not populate it.
1258                 if (!can_access_course($course)) {
1259                     $coursenode->make_active();
1260                     $canviewcourseprofile = false;
1261                     break;
1262                 }
1263
1264                 $this->add_course_essentials($coursenode, $course);
1265
1266                 // Get section number from $cm (if provided) - we need this
1267                 // before loading sections in order to tell it to load this section
1268                 // even if it would not normally display (=> it contains only
1269                 // a label, which we are now editing)
1270                 $sectionnum = isset($cm->sectionnum) ? $cm->sectionnum : 0;
1271                 if ($sectionnum) {
1272                     // This value has to be stored in a member variable because
1273                     // otherwise we would have to pass it through a public API
1274                     // to course formats and they would need to change their
1275                     // functions to pass it along again...
1276                     $this->includesectionnum = $sectionnum;
1277                 } else {
1278                     $this->includesectionnum = false;
1279                 }
1280
1281                 // Load the course sections into the page
1282                 $sections = $this->load_course_sections($course, $coursenode);
1283                 if ($course->id != SITEID) {
1284                     // Find the section for the $CM associated with the page and collect
1285                     // its section number.
1286                     if ($sectionnum) {
1287                         $cm->sectionnumber = $sectionnum;
1288                     } else {
1289                         foreach ($sections as $section) {
1290                             if ($section->id == $cm->section) {
1291                                 $cm->sectionnumber = $section->section;
1292                                 break;
1293                             }
1294                         }
1295                     }
1296
1297                     // Load all of the section activities for the section the cm belongs to.
1298                     if (isset($cm->sectionnumber) and !empty($sections[$cm->sectionnumber])) {
1299                         list($sectionarray, $activityarray) = $this->generate_sections_and_activities($course);
1300                         $activities = $this->load_section_activities($sections[$cm->sectionnumber]->sectionnode, $cm->sectionnumber, $activityarray);
1301                     } else {
1302                         $activities = array();
1303                         if ($activity = $this->load_stealth_activity($coursenode, get_fast_modinfo($course))) {
1304                             // "stealth" activity from unavailable section
1305                             $activities[$cm->id] = $activity;
1306                         }
1307                     }
1308                 } else {
1309                     $activities = array();
1310                     $activities[$cm->id] = $coursenode->get($cm->id, navigation_node::TYPE_ACTIVITY);
1311                 }
1312                 if (!empty($activities[$cm->id])) {
1313                     // Finally load the cm specific navigaton information
1314                     $this->load_activity($cm, $course, $activities[$cm->id]);
1315                     // Check if we have an active ndoe
1316                     if (!$activities[$cm->id]->contains_active_node() && !$activities[$cm->id]->search_for_active_node()) {
1317                         // And make the activity node active.
1318                         $activities[$cm->id]->make_active();
1319                     }
1320                 } else {
1321                     //TODO: something is wrong, what to do? (Skodak)
1322                 }
1323                 break;
1324             case CONTEXT_USER :
1325                 if ($issite) {
1326                     // The users profile information etc is already loaded
1327                     // for the front page.
1328                     break;
1329                 }
1330                 $course = $this->page->course;
1331                 if ($showcategories && !$ismycourse) {
1332                     $this->load_all_categories($course->category, $showcategories);
1333                 }
1334                 // Load the course associated with the user into the navigation
1335                 $coursenode = $this->load_course($course);
1336
1337                 // If the course wasn't added then don't try going any further.
1338                 if (!$coursenode) {
1339                     $canviewcourseprofile = false;
1340                     break;
1341                 }
1342
1343                 // If the user is not enrolled then we only want to show the
1344                 // course node and not populate it.
1345                 if (!can_access_course($course)) {
1346                     $coursenode->make_active();
1347                     $canviewcourseprofile = false;
1348                     break;
1349                 }
1350                 $this->add_course_essentials($coursenode, $course);
1351                 $sections = $this->load_course_sections($course, $coursenode);
1352                 break;
1353         }
1354
1355         $limit = 20;
1356         if (!empty($CFG->navcourselimit)) {
1357             $limit = $CFG->navcourselimit;
1358         }
1359         if ($showcategories) {
1360             $categories = $this->find_all_of_type(self::TYPE_CATEGORY);
1361             foreach ($categories as &$category) {
1362                 if ($category->children->count() >= $limit) {
1363                     $url = new moodle_url('/course/category.php', array('id'=>$category->key));
1364                     $category->add(get_string('viewallcourses'), $url, self::TYPE_SETTING);
1365                 }
1366             }
1367         } else if ($this->rootnodes['courses']->children->count() >= $limit) {
1368             $this->rootnodes['courses']->add(get_string('viewallcoursescategories'), new moodle_url('/course/index.php'), self::TYPE_SETTING);
1369         }
1370
1371         // Load for the current user
1372         $this->load_for_user();
1373         if ($this->page->context->contextlevel >= CONTEXT_COURSE && $this->page->context->instanceid != SITEID && $canviewcourseprofile) {
1374             $this->load_for_user(null, true);
1375         }
1376         // Load each extending user into the navigation.
1377         foreach ($this->extendforuser as $user) {
1378             if ($user->id != $USER->id) {
1379                 $this->load_for_user($user);
1380             }
1381         }
1382
1383         // Give the local plugins a chance to include some navigation if they want.
1384         foreach (get_list_of_plugins('local') as $plugin) {
1385             if (!file_exists($CFG->dirroot.'/local/'.$plugin.'/lib.php')) {
1386                 continue;
1387             }
1388             require_once($CFG->dirroot.'/local/'.$plugin.'/lib.php');
1389             $function = $plugin.'_extends_navigation';
1390             if (function_exists($function)) {
1391                 $function($this);
1392             }
1393         }
1394
1395         // Remove any empty root nodes
1396         foreach ($this->rootnodes as $node) {
1397             // Dont remove the home node
1398             if ($node->key !== 'home' && !$node->has_children()) {
1399                 $node->remove();
1400             }
1401         }
1402
1403         if (!$this->contains_active_node()) {
1404             $this->search_for_active_node();
1405         }
1406
1407         // If the user is not logged in modify the navigation structure as detailed
1408         // in {@link http://docs.moodle.org/dev/Navigation_2.0_structure}
1409         if (!isloggedin()) {
1410             $activities = clone($this->rootnodes['site']->children);
1411             $this->rootnodes['site']->remove();
1412             $children = clone($this->children);
1413             $this->children = new navigation_node_collection();
1414             foreach ($activities as $child) {
1415                 $this->children->add($child);
1416             }
1417             foreach ($children as $child) {
1418                 $this->children->add($child);
1419             }
1420         }
1421         return true;
1422     }
1423
1424     /**
1425      * Returns true if courses should be shown within categories on the navigation.
1426      *
1427      * @return bool
1428      */
1429     protected function show_categories() {
1430         global $CFG, $DB;
1431         if ($this->showcategories === null) {
1432             $show = $this->page->context->contextlevel == CONTEXT_COURSECAT;
1433             $show = $show || (!empty($CFG->navshowcategories) && $DB->count_records('course_categories') > 1);
1434             $this->showcategories = $show;
1435         }
1436         return $this->showcategories;
1437     }
1438
1439     /**
1440      * Checks the course format to see whether it wants the navigation to load
1441      * additional information for the course.
1442      *
1443      * This function utilises a callback that can exist within the course format lib.php file
1444      * The callback should be a function called:
1445      * callback_{formatname}_display_content()
1446      * It doesn't get any arguments and should return true if additional content is
1447      * desired. If the callback doesn't exist we assume additional content is wanted.
1448      *
1449      * @param string $format The course format
1450      * @return bool
1451      */
1452     protected function format_display_course_content($format) {
1453         global $CFG;
1454         $formatlib = $CFG->dirroot.'/course/format/'.$format.'/lib.php';
1455         if (file_exists($formatlib)) {
1456             require_once($formatlib);
1457             $displayfunc = 'callback_'.$format.'_display_content';
1458             if (function_exists($displayfunc) && !$displayfunc()) {
1459                 return $displayfunc();
1460             }
1461         }
1462         return true;
1463     }
1464
1465     /**
1466      * Loads the courses in Moodle into the navigation.
1467      *
1468      * @param mixed $categoryids Either a string or array of category ids to load courses for
1469      * @return array An array of navigation_node
1470      */
1471     protected function load_all_courses($categoryids=null) {
1472         global $CFG, $DB, $USER;
1473
1474         if ($categoryids !== null) {
1475             if (is_array($categoryids)) {
1476                 list ($categoryselect, $params) = $DB->get_in_or_equal($categoryids, SQL_PARAMS_NAMED, 'catid');
1477             } else {
1478                 $categoryselect = '= :categoryid';
1479                 $params = array('categoryid', $categoryids);
1480             }
1481             $params['siteid'] = SITEID;
1482             $categoryselect = ' AND c.category '.$categoryselect;
1483         } else {
1484             $params = array('siteid' => SITEID);
1485             $categoryselect = '';
1486         }
1487
1488         $ccselect = context_helper::get_preload_record_columns_sql('ctx');
1489         $params['contextlevel'] = CONTEXT_COURSE;
1490         list($courseids, $courseparams) = $DB->get_in_or_equal(array_keys($this->addedcourses) + array(SITEID), SQL_PARAMS_NAMED, 'lcourse', false);
1491         $sql = "SELECT c.id, c.sortorder, c.visible, c.fullname, c.shortname, c.category, cat.path AS categorypath, $ccselect
1492                   FROM {course} c
1493                   JOIN {context} ctx ON c.id = ctx.instanceid
1494              LEFT JOIN {course_categories} cat ON cat.id=c.category
1495                  WHERE c.id {$courseids} AND
1496                        ctx.contextlevel = :contextlevel
1497                        {$categoryselect}
1498               ORDER BY c.sortorder ASC";
1499         $limit = 20;
1500         if (!empty($CFG->navcourselimit)) {
1501             $limit = $CFG->navcourselimit;
1502         }
1503         $courses = $DB->get_records_sql($sql, $params + $courseparams, 0, $limit);
1504
1505         $coursenodes = array();
1506         foreach ($courses as $course) {
1507             context_helper::preload_from_record($course);
1508             $coursenodes[$course->id] = $this->add_course($course);
1509         }
1510         return $coursenodes;
1511     }
1512
1513     /**
1514      * Loads all categories (top level or if an id is specified for that category)
1515      *
1516      * @param int $categoryid The category id to load or null/0 to load all base level categories
1517      * @param bool $showbasecategories If set to true all base level categories will be loaded as well
1518      *        as the requested category and any parent categories.
1519      * @return navigation_node|void returns a navigation node if a category has been loaded.
1520      */
1521     protected function load_all_categories($categoryid = null, $showbasecategories = false) {
1522         global $DB;
1523
1524         // Check if this category has already been loaded
1525         if ($categoryid !== null && array_key_exists($categoryid, $this->addedcategories) && $this->addedcategories[$categoryid]->children->count() > 0) {
1526             return $this->addedcategories[$categoryid];
1527         }
1528
1529         $coursestoload = array();
1530         if (empty($categoryid)) { // can be 0
1531             // We are going to load all of the first level categories (categories without parents)
1532             $categories = $DB->get_records('course_categories', array('parent'=>'0'), 'sortorder ASC, id ASC');
1533         } else if (array_key_exists($categoryid, $this->addedcategories)) {
1534             // The category itself has been loaded already so we just need to ensure its subcategories
1535             // have been loaded
1536             list($sql, $params) = $DB->get_in_or_equal(array_keys($this->addedcategories), SQL_PARAMS_NAMED, 'parent', false);
1537             if ($showbasecategories) {
1538                 // We need to include categories with parent = 0 as well
1539                 $sql = "SELECT *
1540                           FROM {course_categories} cc
1541                          WHERE (parent = :categoryid OR parent = 0) AND
1542                                parent {$sql}
1543                       ORDER BY depth DESC, sortorder ASC, id ASC";
1544             } else {
1545                 $sql = "SELECT *
1546                           FROM {course_categories} cc
1547                          WHERE parent = :categoryid AND
1548                                parent {$sql}
1549                       ORDER BY depth DESC, sortorder ASC, id ASC";
1550             }
1551             $params['categoryid'] = $categoryid;
1552             $categories = $DB->get_records_sql($sql, $params);
1553             if (count($categories) == 0) {
1554                 // There are no further categories that require loading.
1555                 return;
1556             }
1557         } else {
1558             // This category hasn't been loaded yet so we need to fetch it, work out its category path
1559             // and load this category plus all its parents and subcategories
1560             $category = $DB->get_record('course_categories', array('id' => $categoryid), 'path', MUST_EXIST);
1561             $coursestoload = explode('/', trim($category->path, '/'));
1562             list($select, $params) = $DB->get_in_or_equal($coursestoload);
1563             $select = 'id '.$select.' OR parent '.$select;
1564             if ($showbasecategories) {
1565                 $select .= ' OR parent = 0';
1566             }
1567             $params = array_merge($params, $params);
1568             $categories = $DB->get_records_select('course_categories', $select, $params, 'sortorder');
1569         }
1570
1571         // Now we have an array of categories we need to add them to the navigation.
1572         while (!empty($categories)) {
1573             $category = reset($categories);
1574             if (array_key_exists($category->id, $this->addedcategories)) {
1575                 // Do nothing
1576             } else if ($category->parent == '0') {
1577                 $this->add_category($category, $this->rootnodes['courses']);
1578             } else if (array_key_exists($category->parent, $this->addedcategories)) {
1579                 $this->add_category($category, $this->addedcategories[$category->parent]);
1580             } else {
1581                 // This category isn't in the navigation and niether is it's parent (yet).
1582                 // We need to go through the category path and add all of its components in order.
1583                 $path = explode('/', trim($category->path, '/'));
1584                 foreach ($path as $catid) {
1585                     if (!array_key_exists($catid, $this->addedcategories)) {
1586                         // This category isn't in the navigation yet so add it.
1587                         $subcategory = $categories[$catid];
1588                         if ($subcategory->parent == '0') {
1589                             // Yay we have a root category - this likely means we will now be able
1590                             // to add categories without problems.
1591                             $this->add_category($subcategory, $this->rootnodes['courses']);
1592                         } else if (array_key_exists($subcategory->parent, $this->addedcategories)) {
1593                             // The parent is in the category (as we'd expect) so add it now.
1594                             $this->add_category($subcategory, $this->addedcategories[$subcategory->parent]);
1595                             // Remove the category from the categories array.
1596                             unset($categories[$catid]);
1597                         } else {
1598                             // We should never ever arrive here - if we have then there is a bigger
1599                             // problem at hand.
1600                             throw new coding_exception('Category path order is incorrect and/or there are missing categories');
1601                         }
1602                     }
1603                 }
1604             }
1605             // Remove the category from the categories array now that we know it has been added.
1606             unset($categories[$category->id]);
1607         }
1608         // Check if there are any categories to load.
1609         if (count($coursestoload) > 0) {
1610             $this->load_all_courses($coursestoload);
1611         }
1612     }
1613
1614     /**
1615      * Adds a structured category to the navigation in the correct order/place
1616      *
1617      * @param stdClass $category
1618      * @param navigation_node $parent
1619      */
1620     protected function add_category(stdClass $category, navigation_node $parent) {
1621         if (array_key_exists($category->id, $this->addedcategories)) {
1622             return;
1623         }
1624         $url = new moodle_url('/course/category.php', array('id' => $category->id));
1625         $context = get_context_instance(CONTEXT_COURSECAT, $category->id);
1626         $categoryname = format_string($category->name, true, array('context' => $context));
1627         $categorynode = $parent->add($categoryname, $url, self::TYPE_CATEGORY, $categoryname, $category->id);
1628         if (empty($category->visible)) {
1629             if (has_capability('moodle/category:viewhiddencategories', get_system_context())) {
1630                 $categorynode->hidden = true;
1631             } else {
1632                 $categorynode->display = false;
1633             }
1634         }
1635         $this->addedcategories[$category->id] = &$categorynode;
1636     }
1637
1638     /**
1639      * Loads the given course into the navigation
1640      *
1641      * @param stdClass $course
1642      * @return navigation_node
1643      */
1644     protected function load_course(stdClass $course) {
1645         if ($course->id == SITEID) {
1646             return $this->rootnodes['site'];
1647         } else if (array_key_exists($course->id, $this->addedcourses)) {
1648             return $this->addedcourses[$course->id];
1649         } else {
1650             return $this->add_course($course);
1651         }
1652     }
1653
1654     /**
1655      * Loads all of the courses section into the navigation.
1656      *
1657      * This function utilisies a callback that can be implemented within the course
1658      * formats lib.php file to customise the navigation that is generated at this
1659      * point for the course.
1660      *
1661      * By default (if not defined) the method {@link global_navigation::load_generic_course_sections()} is
1662      * called instead.
1663      *
1664      * @param stdClass $course Database record for the course
1665      * @param navigation_node $coursenode The course node within the navigation
1666      * @return array Array of navigation nodes for the section with key = section id
1667      */
1668     protected function load_course_sections(stdClass $course, navigation_node $coursenode) {
1669         global $CFG;
1670         $structurefile = $CFG->dirroot.'/course/format/'.$course->format.'/lib.php';
1671         $structurefunc = 'callback_'.$course->format.'_load_content';
1672         if (function_exists($structurefunc)) {
1673             return $structurefunc($this, $course, $coursenode);
1674         } else if (file_exists($structurefile)) {
1675             require_once $structurefile;
1676             if (function_exists($structurefunc)) {
1677                 return $structurefunc($this, $course, $coursenode);
1678             } else {
1679                 return $this->load_generic_course_sections($course, $coursenode);
1680             }
1681         } else {
1682             return $this->load_generic_course_sections($course, $coursenode);
1683         }
1684     }
1685
1686     /**
1687      * Generates an array of sections and an array of activities for the given course.
1688      *
1689      * This method uses the cache to improve performance and avoid the get_fast_modinfo call
1690      *
1691      * @param stdClass $course
1692      * @return array Array($sections, $activities)
1693      */
1694     protected function generate_sections_and_activities(stdClass $course) {
1695         global $CFG;
1696         require_once($CFG->dirroot.'/course/lib.php');
1697
1698         $modinfo = get_fast_modinfo($course);
1699
1700         $sections = array_slice(get_all_sections($course->id), 0, $course->numsections+1, true);
1701         $activities = array();
1702
1703         foreach ($sections as $key => $section) {
1704             $sections[$key]->hasactivites = false;
1705             if (!array_key_exists($section->section, $modinfo->sections)) {
1706                 continue;
1707             }
1708             foreach ($modinfo->sections[$section->section] as $cmid) {
1709                 $cm = $modinfo->cms[$cmid];
1710                 if (!$cm->uservisible) {
1711                     continue;
1712                 }
1713                 $activity = new stdClass;
1714                 $activity->id = $cm->id;
1715                 $activity->course = $course->id;
1716                 $activity->section = $section->section;
1717                 $activity->name = $cm->name;
1718                 $activity->icon = $cm->icon;
1719                 $activity->iconcomponent = $cm->iconcomponent;
1720                 $activity->hidden = (!$cm->visible);
1721                 $activity->modname = $cm->modname;
1722                 $activity->nodetype = navigation_node::NODETYPE_LEAF;
1723                 $activity->onclick = $cm->get_on_click();
1724                 $url = $cm->get_url();
1725                 if (!$url) {
1726                     $activity->url = null;
1727                     $activity->display = false;
1728                 } else {
1729                     $activity->url = $cm->get_url()->out();
1730                     $activity->display = true;
1731                     if (self::module_extends_navigation($cm->modname)) {
1732                         $activity->nodetype = navigation_node::NODETYPE_BRANCH;
1733                     }
1734                 }
1735                 $activities[$cmid] = $activity;
1736                 if ($activity->display) {
1737                     $sections[$key]->hasactivites = true;
1738                 }
1739             }
1740         }
1741
1742         return array($sections, $activities);
1743     }
1744
1745     /**
1746      * Generically loads the course sections into the course's navigation.
1747      *
1748      * @param stdClass $course
1749      * @param navigation_node $coursenode
1750      * @param string $courseformat The course format
1751      * @return array An array of course section nodes
1752      */
1753     public function load_generic_course_sections(stdClass $course, navigation_node $coursenode, $courseformat='unknown') {
1754         global $CFG, $DB, $USER;
1755         require_once($CFG->dirroot.'/course/lib.php');
1756
1757         list($sections, $activities) = $this->generate_sections_and_activities($course);
1758
1759         $namingfunction = 'callback_'.$courseformat.'_get_section_name';
1760         $namingfunctionexists = (function_exists($namingfunction));
1761
1762         $viewhiddensections = has_capability('moodle/course:viewhiddensections', $this->page->context);
1763
1764         $urlfunction = 'callback_'.$courseformat.'_get_section_url';
1765         if (function_exists($urlfunction)) {
1766             debugging('Depricated callback_'.$courseformat.'_get_section_url in use.
1767                 Please switch your code to use the standard section url param');
1768         } else {
1769             $urlfunction = null;
1770         }
1771
1772         $key = 0;
1773         if (defined('AJAX_SCRIPT') && AJAX_SCRIPT == '0' && $this->page->url->compare(new moodle_url('/course/view.php'), URL_MATCH_BASE)) {
1774             $key = optional_param('section', $key, PARAM_INT);
1775         }
1776
1777         $navigationsections = array();
1778         foreach ($sections as $sectionid => $section) {
1779             $section = clone($section);
1780             if ($course->id == SITEID) {
1781                 $this->load_section_activities($coursenode, $section->section, $activities);
1782             } else {
1783                 if ((!$viewhiddensections && !$section->visible) || (!$this->showemptysections &&
1784                         !$section->hasactivites && $this->includesectionnum !== $section->section)) {
1785                     continue;
1786                 }
1787                 if ($namingfunctionexists) {
1788                     $sectionname = $namingfunction($course, $section, $sections);
1789                 } else {
1790                     $sectionname = get_string('section').' '.$section->section;
1791                 }
1792
1793                 $url = null;
1794                 if ($urlfunction) {
1795                     // pre 2.3 style format url
1796                     $url = $urlfunction($course->id, $section->section);
1797                 }else{
1798                     if ($course->coursedisplay == COURSE_DISPLAY_MULTIPAGE) {
1799                         $url = course_get_url($course, $section->section);
1800                     }
1801                 }
1802                 $sectionnode = $coursenode->add($sectionname, $url, navigation_node::TYPE_SECTION, null, $section->id);
1803                 $sectionnode->nodetype = navigation_node::NODETYPE_BRANCH;
1804                 $sectionnode->hidden = (!$section->visible);
1805                 if ($key != '0' && $section->section != '0' && $section->section == $key && $this->page->context->contextlevel != CONTEXT_MODULE && $section->hasactivites) {
1806                     $sectionnode->make_active();
1807                     $this->load_section_activities($sectionnode, $section->section, $activities);
1808                 }
1809                 $section->sectionnode = $sectionnode;
1810                 $navigationsections[$sectionid] = $section;
1811             }
1812         }
1813         return $navigationsections;
1814     }
1815     /**
1816      * Loads all of the activities for a section into the navigation structure.
1817      *
1818      * @param navigation_node $sectionnode
1819      * @param int $sectionnumber
1820      * @param array $activities An array of activites as returned by {@link global_navigation::generate_sections_and_activities()}
1821      * @param stdClass $course The course object the section and activities relate to.
1822      * @return array Array of activity nodes
1823      */
1824     protected function load_section_activities(navigation_node $sectionnode, $sectionnumber, array $activities, $course = null) {
1825         global $CFG;
1826         // A static counter for JS function naming
1827         static $legacyonclickcounter = 0;
1828
1829         $activitynodes = array();
1830         if (empty($activities)) {
1831             return $activitynodes;
1832         }
1833
1834         if (!is_object($course)) {
1835             $activity = reset($activities);
1836             $courseid = $activity->course;
1837         } else {
1838             $courseid = $course->id;
1839         }
1840         $showactivities = ($courseid != SITEID || !empty($CFG->navshowfrontpagemods));
1841
1842         foreach ($activities as $activity) {
1843             if ($activity->section != $sectionnumber) {
1844                 continue;
1845             }
1846             if ($activity->icon) {
1847                 $icon = new pix_icon($activity->icon, get_string('modulename', $activity->modname), $activity->iconcomponent);
1848             } else {
1849                 $icon = new pix_icon('icon', get_string('modulename', $activity->modname), $activity->modname);
1850             }
1851
1852             // Prepare the default name and url for the node
1853             $activityname = format_string($activity->name, true, array('context' => get_context_instance(CONTEXT_MODULE, $activity->id)));
1854             $action = new moodle_url($activity->url);
1855
1856             // Check if the onclick property is set (puke!)
1857             if (!empty($activity->onclick)) {
1858                 // Increment the counter so that we have a unique number.
1859                 $legacyonclickcounter++;
1860                 // Generate the function name we will use
1861                 $functionname = 'legacy_activity_onclick_handler_'.$legacyonclickcounter;
1862                 $propogrationhandler = '';
1863                 // Check if we need to cancel propogation. Remember inline onclick
1864                 // events would return false if they wanted to prevent propogation and the
1865                 // default action.
1866                 if (strpos($activity->onclick, 'return false')) {
1867                     $propogrationhandler = 'e.halt();';
1868                 }
1869                 // Decode the onclick - it has already been encoded for display (puke)
1870                 $onclick = htmlspecialchars_decode($activity->onclick);
1871                 // Build the JS function the click event will call
1872                 $jscode = "function {$functionname}(e) { $propogrationhandler $onclick }";
1873                 $this->page->requires->js_init_code($jscode);
1874                 // Override the default url with the new action link
1875                 $action = new action_link($action, $activityname, new component_action('click', $functionname));
1876             }
1877
1878             $activitynode = $sectionnode->add($activityname, $action, navigation_node::TYPE_ACTIVITY, null, $activity->id, $icon);
1879             $activitynode->title(get_string('modulename', $activity->modname));
1880             $activitynode->hidden = $activity->hidden;
1881             $activitynode->display = $showactivities && $activity->display;
1882             $activitynode->nodetype = $activity->nodetype;
1883             $activitynodes[$activity->id] = $activitynode;
1884         }
1885
1886         return $activitynodes;
1887     }
1888     /**
1889      * Loads a stealth module from unavailable section
1890      * @param navigation_node $coursenode
1891      * @param stdClass $modinfo
1892      * @return navigation_node or null if not accessible
1893      */
1894     protected function load_stealth_activity(navigation_node $coursenode, $modinfo) {
1895         if (empty($modinfo->cms[$this->page->cm->id])) {
1896             return null;
1897         }
1898         $cm = $modinfo->cms[$this->page->cm->id];
1899         if (!$cm->uservisible) {
1900             return null;
1901         }
1902         if ($cm->icon) {
1903             $icon = new pix_icon($cm->icon, get_string('modulename', $cm->modname), $cm->iconcomponent);
1904         } else {
1905             $icon = new pix_icon('icon', get_string('modulename', $cm->modname), $cm->modname);
1906         }
1907         $url = $cm->get_url();
1908         $activitynode = $coursenode->add(format_string($cm->name), $url, navigation_node::TYPE_ACTIVITY, null, $cm->id, $icon);
1909         $activitynode->title(get_string('modulename', $cm->modname));
1910         $activitynode->hidden = (!$cm->visible);
1911         if (!$url) {
1912             // Don't show activities that don't have links!
1913             $activitynode->display = false;
1914         } else if (self::module_extends_navigation($cm->modname)) {
1915             $activitynode->nodetype = navigation_node::NODETYPE_BRANCH;
1916         }
1917         return $activitynode;
1918     }
1919     /**
1920      * Loads the navigation structure for the given activity into the activities node.
1921      *
1922      * This method utilises a callback within the modules lib.php file to load the
1923      * content specific to activity given.
1924      *
1925      * The callback is a method: {modulename}_extend_navigation()
1926      * Examples:
1927      *  * {@link forum_extend_navigation()}
1928      *  * {@link workshop_extend_navigation()}
1929      *
1930      * @param cm_info|stdClass $cm
1931      * @param stdClass $course
1932      * @param navigation_node $activity
1933      * @return bool
1934      */
1935     protected function load_activity($cm, stdClass $course, navigation_node $activity) {
1936         global $CFG, $DB;
1937
1938         // make sure we have a $cm from get_fast_modinfo as this contains activity access details
1939         if (!($cm instanceof cm_info)) {
1940             $modinfo = get_fast_modinfo($course);
1941             $cm = $modinfo->get_cm($cm->id);
1942         }
1943
1944         $activity->nodetype = navigation_node::NODETYPE_LEAF;
1945         $activity->make_active();
1946         $file = $CFG->dirroot.'/mod/'.$cm->modname.'/lib.php';
1947         $function = $cm->modname.'_extend_navigation';
1948
1949         if (file_exists($file)) {
1950             require_once($file);
1951             if (function_exists($function)) {
1952                 $activtyrecord = $DB->get_record($cm->modname, array('id' => $cm->instance), '*', MUST_EXIST);
1953                 $function($activity, $course, $activtyrecord, $cm);
1954             }
1955         }
1956
1957         // Allow the active advanced grading method plugin to append module navigation
1958         $featuresfunc = $cm->modname.'_supports';
1959         if (function_exists($featuresfunc) && $featuresfunc(FEATURE_ADVANCED_GRADING)) {
1960             require_once($CFG->dirroot.'/grade/grading/lib.php');
1961             $gradingman = get_grading_manager($cm->context, $cm->modname);
1962             $gradingman->extend_navigation($this, $activity);
1963         }
1964
1965         return $activity->has_children();
1966     }
1967     /**
1968      * Loads user specific information into the navigation in the appropriate place.
1969      *
1970      * If no user is provided the current user is assumed.
1971      *
1972      * @param stdClass $user
1973      * @param bool $forceforcontext probably force something to be loaded somewhere (ask SamH if not sure what this means)
1974      * @return bool
1975      */
1976     protected function load_for_user($user=null, $forceforcontext=false) {
1977         global $DB, $CFG, $USER;
1978
1979         if ($user === null) {
1980             // We can't require login here but if the user isn't logged in we don't
1981             // want to show anything
1982             if (!isloggedin() || isguestuser()) {
1983                 return false;
1984             }
1985             $user = $USER;
1986         } else if (!is_object($user)) {
1987             // If the user is not an object then get them from the database
1988             $select = context_helper::get_preload_record_columns_sql('ctx');
1989             $sql = "SELECT u.*, $select
1990                       FROM {user} u
1991                       JOIN {context} ctx ON u.id = ctx.instanceid
1992                      WHERE u.id = :userid AND
1993                            ctx.contextlevel = :contextlevel";
1994             $user = $DB->get_record_sql($sql, array('userid' => (int)$user, 'contextlevel' => CONTEXT_USER), MUST_EXIST);
1995             context_helper::preload_from_record($user);
1996         }
1997
1998         $iscurrentuser = ($user->id == $USER->id);
1999
2000         $usercontext = get_context_instance(CONTEXT_USER, $user->id);
2001
2002         // Get the course set against the page, by default this will be the site
2003         $course = $this->page->course;
2004         $baseargs = array('id'=>$user->id);
2005         if ($course->id != SITEID && (!$iscurrentuser || $forceforcontext)) {
2006             $coursenode = $this->load_course($course);
2007             $baseargs['course'] = $course->id;
2008             $coursecontext = get_context_instance(CONTEXT_COURSE, $course->id);
2009             $issitecourse = false;
2010         } else {
2011             // Load all categories and get the context for the system
2012             $coursecontext = get_context_instance(CONTEXT_SYSTEM);
2013             $issitecourse = true;
2014         }
2015
2016         // Create a node to add user information under.
2017         if ($iscurrentuser && !$forceforcontext) {
2018             // If it's the current user the information will go under the profile root node
2019             $usernode = $this->rootnodes['myprofile'];
2020             $course = get_site();
2021             $coursecontext = get_context_instance(CONTEXT_COURSE, $course->id);
2022             $issitecourse = true;
2023         } else {
2024             if (!$issitecourse) {
2025                 // Not the current user so add it to the participants node for the current course
2026                 $usersnode = $coursenode->get('participants', navigation_node::TYPE_CONTAINER);
2027                 $userviewurl = new moodle_url('/user/view.php', $baseargs);
2028             } else {
2029                 // This is the site so add a users node to the root branch
2030                 $usersnode = $this->rootnodes['users'];
2031                 if (has_capability('moodle/course:viewparticipants', $coursecontext)) {
2032                     $usersnode->action = new moodle_url('/user/index.php', array('id'=>$course->id));
2033                 }
2034                 $userviewurl = new moodle_url('/user/profile.php', $baseargs);
2035             }
2036             if (!$usersnode) {
2037                 // We should NEVER get here, if the course hasn't been populated
2038                 // with a participants node then the navigaiton either wasn't generated
2039                 // for it (you are missing a require_login or set_context call) or
2040                 // you don't have access.... in the interests of no leaking informatin
2041                 // we simply quit...
2042                 return false;
2043             }
2044             // Add a branch for the current user
2045             $canseefullname = has_capability('moodle/site:viewfullnames', $coursecontext);
2046             $usernode = $usersnode->add(fullname($user, $canseefullname), $userviewurl, self::TYPE_USER, null, $user->id);
2047
2048             if ($this->page->context->contextlevel == CONTEXT_USER && $user->id == $this->page->context->instanceid) {
2049                 $usernode->make_active();
2050             }
2051         }
2052
2053         // If the user is the current user or has permission to view the details of the requested
2054         // user than add a view profile link.
2055         if ($iscurrentuser || has_capability('moodle/user:viewdetails', $coursecontext) || has_capability('moodle/user:viewdetails', $usercontext)) {
2056             if ($issitecourse || ($iscurrentuser && !$forceforcontext)) {
2057                 $usernode->add(get_string('viewprofile'), new moodle_url('/user/profile.php',$baseargs));
2058             } else {
2059                 $usernode->add(get_string('viewprofile'), new moodle_url('/user/view.php',$baseargs));
2060             }
2061         }
2062
2063         if (!empty($CFG->navadduserpostslinks)) {
2064             // Add nodes for forum posts and discussions if the user can view either or both
2065             // There are no capability checks here as the content of the page is based
2066             // purely on the forums the current user has access too.
2067             $forumtab = $usernode->add(get_string('forumposts', 'forum'));
2068             $forumtab->add(get_string('posts', 'forum'), new moodle_url('/mod/forum/user.php', $baseargs));
2069             $forumtab->add(get_string('discussions', 'forum'), new moodle_url('/mod/forum/user.php', array_merge($baseargs, array('mode'=>'discussions'))));
2070         }
2071
2072         // Add blog nodes
2073         if (!empty($CFG->bloglevel)) {
2074             if (!$this->cache->cached('userblogoptions'.$user->id)) {
2075                 require_once($CFG->dirroot.'/blog/lib.php');
2076                 // Get all options for the user
2077                 $options = blog_get_options_for_user($user);
2078                 $this->cache->set('userblogoptions'.$user->id, $options);
2079             } else {
2080                 $options = $this->cache->{'userblogoptions'.$user->id};
2081             }
2082
2083             if (count($options) > 0) {
2084                 $blogs = $usernode->add(get_string('blogs', 'blog'), null, navigation_node::TYPE_CONTAINER);
2085                 foreach ($options as $type => $option) {
2086                     if ($type == "rss") {
2087                         $blogs->add($option['string'], $option['link'], settings_navigation::TYPE_SETTING, null, null, new pix_icon('i/rss', ''));
2088                     } else {
2089                         $blogs->add($option['string'], $option['link']);
2090                     }
2091                 }
2092             }
2093         }
2094
2095         if (!empty($CFG->messaging)) {
2096             $messageargs = null;
2097             if ($USER->id!=$user->id) {
2098                 $messageargs = array('id'=>$user->id);
2099             }
2100             $url = new moodle_url('/message/index.php',$messageargs);
2101             $usernode->add(get_string('messages', 'message'), $url, self::TYPE_SETTING, null, 'messages');
2102         }
2103
2104         $context = get_context_instance(CONTEXT_USER, $USER->id);
2105         if ($iscurrentuser && has_capability('moodle/user:manageownfiles', $context)) {
2106             $url = new moodle_url('/user/files.php');
2107             $usernode->add(get_string('myfiles'), $url, self::TYPE_SETTING);
2108         }
2109
2110         // Add a node to view the users notes if permitted
2111         if (!empty($CFG->enablenotes) && has_any_capability(array('moodle/notes:manage', 'moodle/notes:view'), $coursecontext)) {
2112             $url = new moodle_url('/notes/index.php',array('user'=>$user->id));
2113             if ($coursecontext->instanceid) {
2114                 $url->param('course', $coursecontext->instanceid);
2115             }
2116             $usernode->add(get_string('notes', 'notes'), $url);
2117         }
2118
2119         // Add reports node
2120         $reporttab = $usernode->add(get_string('activityreports'));
2121         $reports = get_plugin_list_with_function('report', 'extend_navigation_user', 'lib.php');
2122         foreach ($reports as $reportfunction) {
2123             $reportfunction($reporttab, $user, $course);
2124         }
2125         $anyreport = has_capability('moodle/user:viewuseractivitiesreport', $usercontext);
2126         if ($anyreport || ($course->showreports && $iscurrentuser && $forceforcontext)) {
2127             // Add grade hardcoded grade report if necessary
2128             $gradeaccess = false;
2129             if (has_capability('moodle/grade:viewall', $coursecontext)) {
2130                 //ok - can view all course grades
2131                 $gradeaccess = true;
2132             } else if ($course->showgrades) {
2133                 if ($iscurrentuser && has_capability('moodle/grade:view', $coursecontext)) {
2134                     //ok - can view own grades
2135                     $gradeaccess = true;
2136                 } else if (has_capability('moodle/grade:viewall', $usercontext)) {
2137                     // ok - can view grades of this user - parent most probably
2138                     $gradeaccess = true;
2139                 } else if ($anyreport) {
2140                     // ok - can view grades of this user - parent most probably
2141                     $gradeaccess = true;
2142                 }
2143             }
2144             if ($gradeaccess) {
2145                 $reporttab->add(get_string('grade'), new moodle_url('/course/user.php', array('mode'=>'grade', 'id'=>$course->id, 'user'=>$usercontext->instanceid)));
2146             }
2147         }
2148         // Check the number of nodes in the report node... if there are none remove the node
2149         $reporttab->trim_if_empty();
2150
2151         // If the user is the current user add the repositories for the current user
2152         $hiddenfields = array_flip(explode(',', $CFG->hiddenuserfields));
2153         if ($iscurrentuser) {
2154             if (!$this->cache->cached('contexthasrepos'.$usercontext->id)) {
2155                 require_once($CFG->dirroot . '/repository/lib.php');
2156                 $editabletypes = repository::get_editable_types($usercontext);
2157                 $haseditabletypes = !empty($editabletypes);
2158                 unset($editabletypes);
2159                 $this->cache->set('contexthasrepos'.$usercontext->id, $haseditabletypes);
2160             } else {
2161                 $haseditabletypes = $this->cache->{'contexthasrepos'.$usercontext->id};
2162             }
2163             if ($haseditabletypes) {
2164                 $usernode->add(get_string('repositories', 'repository'), new moodle_url('/repository/manage_instances.php', array('contextid' => $usercontext->id)));
2165             }
2166         } else if ($course->id == SITEID && has_capability('moodle/user:viewdetails', $usercontext) && (!in_array('mycourses', $hiddenfields) || has_capability('moodle/user:viewhiddendetails', $coursecontext))) {
2167
2168             // Add view grade report is permitted
2169             $reports = get_plugin_list('gradereport');
2170             arsort($reports); // user is last, we want to test it first
2171
2172             $userscourses = enrol_get_users_courses($user->id);
2173             $userscoursesnode = $usernode->add(get_string('courses'));
2174
2175             foreach ($userscourses as $usercourse) {
2176                 $usercoursecontext = get_context_instance(CONTEXT_COURSE, $usercourse->id);
2177                 $usercourseshortname = format_string($usercourse->shortname, true, array('context' => $usercoursecontext));
2178                 $usercoursenode = $userscoursesnode->add($usercourseshortname, new moodle_url('/user/view.php', array('id'=>$user->id, 'course'=>$usercourse->id)), self::TYPE_CONTAINER);
2179
2180                 $gradeavailable = has_capability('moodle/grade:viewall', $usercoursecontext);
2181                 if (!$gradeavailable && !empty($usercourse->showgrades) && is_array($reports) && !empty($reports)) {
2182                     foreach ($reports as $plugin => $plugindir) {
2183                         if (has_capability('gradereport/'.$plugin.':view', $usercoursecontext)) {
2184                             //stop when the first visible plugin is found
2185                             $gradeavailable = true;
2186                             break;
2187                         }
2188                     }
2189                 }
2190
2191                 if ($gradeavailable) {
2192                     $url = new moodle_url('/grade/report/index.php', array('id'=>$usercourse->id));
2193                     $usercoursenode->add(get_string('grades'), $url, self::TYPE_SETTING, null, null, new pix_icon('i/grades', ''));
2194                 }
2195
2196                 // Add a node to view the users notes if permitted
2197                 if (!empty($CFG->enablenotes) && has_any_capability(array('moodle/notes:manage', 'moodle/notes:view'), $usercoursecontext)) {
2198                     $url = new moodle_url('/notes/index.php',array('user'=>$user->id, 'course'=>$usercourse->id));
2199                     $usercoursenode->add(get_string('notes', 'notes'), $url, self::TYPE_SETTING);
2200                 }
2201
2202                 if (can_access_course($usercourse, $user->id)) {
2203                     $usercoursenode->add(get_string('entercourse'), new moodle_url('/course/view.php', array('id'=>$usercourse->id)), self::TYPE_SETTING, null, null, new pix_icon('i/course', ''));
2204                 }
2205
2206                 $reporttab = $usercoursenode->add(get_string('activityreports'));
2207
2208                 $reports = get_plugin_list_with_function('report', 'extend_navigation_user', 'lib.php');
2209                 foreach ($reports as $reportfunction) {
2210                     $reportfunction($reporttab, $user, $usercourse);
2211                 }
2212
2213                 $reporttab->trim_if_empty();
2214             }
2215         }
2216         return true;
2217     }
2218
2219     /**
2220      * This method simply checks to see if a given module can extend the navigation.
2221      *
2222      * @todo (MDL-25290) A shared caching solution should be used to save details on what extends navigation.
2223      *
2224      * @param string $modname
2225      * @return bool
2226      */
2227     protected static function module_extends_navigation($modname) {
2228         global $CFG;
2229         static $extendingmodules = array();
2230         if (!array_key_exists($modname, $extendingmodules)) {
2231             $extendingmodules[$modname] = false;
2232             $file = $CFG->dirroot.'/mod/'.$modname.'/lib.php';
2233             if (file_exists($file)) {
2234                 $function = $modname.'_extend_navigation';
2235                 require_once($file);
2236                 $extendingmodules[$modname] = (function_exists($function));
2237             }
2238         }
2239         return $extendingmodules[$modname];
2240     }
2241     /**
2242      * Extends the navigation for the given user.
2243      *
2244      * @param stdClass $user A user from the database
2245      */
2246     public function extend_for_user($user) {
2247         $this->extendforuser[] = $user;
2248     }
2249
2250     /**
2251      * Returns all of the users the navigation is being extended for
2252      *
2253      * @return array An array of extending users.
2254      */
2255     public function get_extending_users() {
2256         return $this->extendforuser;
2257     }
2258     /**
2259      * Adds the given course to the navigation structure.
2260      *
2261      * @param stdClass $course
2262      * @param bool $forcegeneric (optional)
2263      * @param bool $ismycourse (optional)
2264      * @return navigation_node
2265      */
2266     public function add_course(stdClass $course, $forcegeneric = false, $ismycourse = false) {
2267         global $CFG;
2268
2269         // We found the course... we can return it now :)
2270         if (!$forcegeneric && array_key_exists($course->id, $this->addedcourses)) {
2271             return $this->addedcourses[$course->id];
2272         }
2273
2274         $coursecontext = get_context_instance(CONTEXT_COURSE, $course->id);
2275
2276         if ($course->id != SITEID && !$course->visible) {
2277             if (is_role_switched($course->id)) {
2278                 // user has to be able to access course in order to switch, let's skip the visibility test here
2279             } else if (!has_capability('moodle/course:viewhiddencourses', $coursecontext)) {
2280                 return false;
2281             }
2282         }
2283
2284         $issite = ($course->id == SITEID);
2285         $ismycourse = ($ismycourse && !$forcegeneric);
2286         $shortname = format_string($course->shortname, true, array('context' => $coursecontext));
2287
2288         if ($issite) {
2289             $parent = $this;
2290             $url = null;
2291             if (empty($CFG->usesitenameforsitepages)) {
2292                 $shortname = get_string('sitepages');
2293             }
2294         } else if ($ismycourse) {
2295             if (!empty($CFG->navshowmycoursecategories) && ($parent = $this->rootnodes['mycourses']->find($course->category, self::TYPE_CATEGORY))) {
2296                 // Nothing to do here the above statement set $parent to the category within mycourses.
2297             } else {
2298                 $parent = $this->rootnodes['mycourses'];
2299             }
2300             $url = new moodle_url('/course/view.php', array('id'=>$course->id));
2301         } else {
2302             $parent = $this->rootnodes['courses'];
2303             $url = new moodle_url('/course/view.php', array('id'=>$course->id));
2304         }
2305
2306         if (!$ismycourse && !$issite && !empty($course->category)) {
2307             if ($this->show_categories()) {
2308                 // We need to load the category structure for this course
2309                 $this->load_all_categories($course->category);
2310             }
2311             if (array_key_exists($course->category, $this->addedcategories)) {
2312                 $parent = $this->addedcategories[$course->category];
2313                 // This could lead to the course being created so we should check whether it is the case again
2314                 if (!$forcegeneric && array_key_exists($course->id, $this->addedcourses)) {
2315                     return $this->addedcourses[$course->id];
2316                 }
2317             }
2318         }
2319
2320         $coursenode = $parent->add($shortname, $url, self::TYPE_COURSE, $shortname, $course->id);
2321         $coursenode->nodetype = self::NODETYPE_BRANCH;
2322         $coursenode->hidden = (!$course->visible);
2323         $coursenode->title(format_string($course->fullname, true, array('context' => get_context_instance(CONTEXT_COURSE, $course->id))));
2324         if (!$forcegeneric) {
2325             $this->addedcourses[$course->id] = &$coursenode;
2326         }
2327         if ($ismycourse && !empty($CFG->navshowallcourses)) {
2328             // We need to add this course to the general courses node as well as the
2329             // my courses node, rerun the function with the kill param
2330             $genericcourse = $this->add_course($course, true);
2331             if ($genericcourse->isactive) {
2332                 $genericcourse->make_inactive();
2333                 $genericcourse->collapse = true;
2334                 if ($genericcourse->parent && $genericcourse->parent->type == self::TYPE_CATEGORY) {
2335                     $parent = $genericcourse->parent;
2336                     while ($parent && $parent->type == self::TYPE_CATEGORY) {
2337                         $parent->collapse = true;
2338                         $parent = $parent->parent;
2339                     }
2340                 }
2341             }
2342         }
2343
2344         return $coursenode;
2345     }
2346     /**
2347      * Adds essential course nodes to the navigation for the given course.
2348      *
2349      * This method adds nodes such as reports, blogs and participants
2350      *
2351      * @param navigation_node $coursenode
2352      * @param stdClass $course
2353      * @return bool returns true on successful addition of a node.
2354      */
2355     public function add_course_essentials($coursenode, stdClass $course) {
2356         global $CFG;
2357
2358         if ($course->id == SITEID) {
2359             return $this->add_front_page_course_essentials($coursenode, $course);
2360         }
2361
2362         if ($coursenode == false || !($coursenode instanceof navigation_node) || $coursenode->get('participants', navigation_node::TYPE_CONTAINER)) {
2363             return true;
2364         }
2365
2366         //Participants
2367         if (has_capability('moodle/course:viewparticipants', $this->page->context)) {
2368             $participants = $coursenode->add(get_string('participants'), new moodle_url('/user/index.php?id='.$course->id), self::TYPE_CONTAINER, get_string('participants'), 'participants');
2369             $currentgroup = groups_get_course_group($course, true);
2370             if ($course->id == SITEID) {
2371                 $filterselect = '';
2372             } else if ($course->id && !$currentgroup) {
2373                 $filterselect = $course->id;
2374             } else {
2375                 $filterselect = $currentgroup;
2376             }
2377             $filterselect = clean_param($filterselect, PARAM_INT);
2378             if (($CFG->bloglevel == BLOG_GLOBAL_LEVEL or ($CFG->bloglevel == BLOG_SITE_LEVEL and (isloggedin() and !isguestuser())))
2379                and has_capability('moodle/blog:view', get_context_instance(CONTEXT_SYSTEM))) {
2380                 $blogsurls = new moodle_url('/blog/index.php', array('courseid' => $filterselect));
2381                 $participants->add(get_string('blogscourse','blog'), $blogsurls->out());
2382             }
2383             if (!empty($CFG->enablenotes) && (has_capability('moodle/notes:manage', $this->page->context) || has_capability('moodle/notes:view', $this->page->context))) {
2384                 $participants->add(get_string('notes','notes'), new moodle_url('/notes/index.php', array('filtertype'=>'course', 'filterselect'=>$course->id)));
2385             }
2386         } else if (count($this->extendforuser) > 0 || $this->page->course->id == $course->id) {
2387             $participants = $coursenode->add(get_string('participants'), null, self::TYPE_CONTAINER, get_string('participants'), 'participants');
2388         }
2389
2390         // View course reports
2391         if (has_capability('moodle/site:viewreports', $this->page->context)) { // basic capability for listing of reports
2392             $reportnav = $coursenode->add(get_string('reports'), null, self::TYPE_CONTAINER, null, null, new pix_icon('i/stats', ''));
2393             $coursereports = get_plugin_list('coursereport'); // deprecated
2394             foreach ($coursereports as $report=>$dir) {
2395                 $libfile = $CFG->dirroot.'/course/report/'.$report.'/lib.php';
2396                 if (file_exists($libfile)) {
2397                     require_once($libfile);
2398                     $reportfunction = $report.'_report_extend_navigation';
2399                     if (function_exists($report.'_report_extend_navigation')) {
2400                         $reportfunction($reportnav, $course, $this->page->context);
2401                     }
2402                 }
2403             }
2404
2405             $reports = get_plugin_list_with_function('report', 'extend_navigation_course', 'lib.php');
2406             foreach ($reports as $reportfunction) {
2407                 $reportfunction($reportnav, $course, $this->page->context);
2408             }
2409         }
2410         return true;
2411     }
2412     /**
2413      * This generates the structure of the course that won't be generated when
2414      * the modules and sections are added.
2415      *
2416      * Things such as the reports branch, the participants branch, blogs... get
2417      * added to the course node by this method.
2418      *
2419      * @param navigation_node $coursenode
2420      * @param stdClass $course
2421      * @return bool True for successfull generation
2422      */
2423     public function add_front_page_course_essentials(navigation_node $coursenode, stdClass $course) {
2424         global $CFG;
2425
2426         if ($coursenode == false || $coursenode->get('frontpageloaded', navigation_node::TYPE_CUSTOM)) {
2427             return true;
2428         }
2429
2430         // Hidden node that we use to determine if the front page navigation is loaded.
2431         // This required as there are not other guaranteed nodes that may be loaded.
2432         $coursenode->add('frontpageloaded', null, self::TYPE_CUSTOM, null, 'frontpageloaded')->display = false;
2433
2434         //Participants
2435         if (has_capability('moodle/course:viewparticipants',  get_system_context())) {
2436             $coursenode->add(get_string('participants'), new moodle_url('/user/index.php?id='.$course->id), self::TYPE_CUSTOM, get_string('participants'), 'participants');
2437         }
2438
2439         $filterselect = 0;
2440
2441         // Blogs
2442         if (!empty($CFG->bloglevel)
2443           and ($CFG->bloglevel == BLOG_GLOBAL_LEVEL or ($CFG->bloglevel == BLOG_SITE_LEVEL and (isloggedin() and !isguestuser())))
2444           and has_capability('moodle/blog:view', get_context_instance(CONTEXT_SYSTEM))) {
2445             $blogsurls = new moodle_url('/blog/index.php', array('courseid' => $filterselect));
2446             $coursenode->add(get_string('blogssite','blog'), $blogsurls->out());
2447         }
2448
2449         // Notes
2450         if (!empty($CFG->enablenotes) && (has_capability('moodle/notes:manage', $this->page->context) || has_capability('moodle/notes:view', $this->page->context))) {
2451             $coursenode->add(get_string('notes','notes'), new moodle_url('/notes/index.php', array('filtertype'=>'course', 'filterselect'=>$filterselect)));
2452         }
2453
2454         // Tags
2455         if (!empty($CFG->usetags) && isloggedin()) {
2456             $coursenode->add(get_string('tags', 'tag'), new moodle_url('/tag/search.php'));
2457         }
2458
2459         if (isloggedin()) {
2460             // Calendar
2461             $calendarurl = new moodle_url('/calendar/view.php', array('view' => 'month'));
2462             $coursenode->add(get_string('calendar', 'calendar'), $calendarurl, self::TYPE_CUSTOM, null, 'calendar');
2463         }
2464
2465         // View course reports
2466         if (has_capability('moodle/site:viewreports', $this->page->context)) { // basic capability for listing of reports
2467             $reportnav = $coursenode->add(get_string('reports'), null, self::TYPE_CONTAINER, null, null, new pix_icon('i/stats', ''));
2468             $coursereports = get_plugin_list('coursereport'); // deprecated
2469             foreach ($coursereports as $report=>$dir) {
2470                 $libfile = $CFG->dirroot.'/course/report/'.$report.'/lib.php';
2471                 if (file_exists($libfile)) {
2472                     require_once($libfile);
2473                     $reportfunction = $report.'_report_extend_navigation';
2474                     if (function_exists($report.'_report_extend_navigation')) {
2475                         $reportfunction($reportnav, $course, $this->page->context);
2476                     }
2477                 }
2478             }
2479
2480             $reports = get_plugin_list_with_function('report', 'extend_navigation_course', 'lib.php');
2481             foreach ($reports as $reportfunction) {
2482                 $reportfunction($reportnav, $course, $this->page->context);
2483             }
2484         }
2485         return true;
2486     }
2487
2488     /**
2489      * Clears the navigation cache
2490      */
2491     public function clear_cache() {
2492         $this->cache->clear();
2493     }
2494
2495     /**
2496      * Sets an expansion limit for the navigation
2497      *
2498      * The expansion limit is used to prevent the display of content that has a type
2499      * greater than the provided $type.
2500      *
2501      * Can be used to ensure things such as activities or activity content don't get
2502      * shown on the navigation.
2503      * They are still generated in order to ensure the navbar still makes sense.
2504      *
2505      * @param int $type One of navigation_node::TYPE_*
2506      * @return bool true when complete.
2507      */
2508     public function set_expansion_limit($type) {
2509         $nodes = $this->find_all_of_type($type);
2510         foreach ($nodes as &$node) {
2511             // We need to generate the full site node
2512             if ($type == self::TYPE_COURSE && $node->key == SITEID) {
2513                 continue;
2514             }
2515             foreach ($node->children as &$child) {
2516                 // We still want to show course reports and participants containers
2517                 // or there will be navigation missing.
2518                 if ($type == self::TYPE_COURSE && $child->type === self::TYPE_CONTAINER) {
2519                     continue;
2520                 }
2521                 $child->display = false;
2522             }
2523         }
2524         return true;
2525     }
2526     /**
2527      * Attempts to get the navigation with the given key from this nodes children.
2528      *
2529      * This function only looks at this nodes children, it does NOT look recursivily.
2530      * If the node can't be found then false is returned.
2531      *
2532      * If you need to search recursivily then use the {@link global_navigation::find()} method.
2533      *
2534      * Note: If you are trying to set the active node {@link navigation_node::override_active_url()}
2535      * may be of more use to you.
2536      *
2537      * @param string|int $key The key of the node you wish to receive.
2538      * @param int $type One of navigation_node::TYPE_*
2539      * @return navigation_node|false
2540      */
2541     public function get($key, $type = null) {
2542         if (!$this->initialised) {
2543             $this->initialise();
2544         }
2545         return parent::get($key, $type);
2546     }
2547
2548     /**
2549      * Searches this nodes children and their children to find a navigation node
2550      * with the matching key and type.
2551      *
2552      * This method is recursive and searches children so until either a node is
2553      * found or there are no more nodes to search.
2554      *
2555      * If you know that the node being searched for is a child of this node
2556      * then use the {@link global_navigation::get()} method instead.
2557      *
2558      * Note: If you are trying to set the active node {@link navigation_node::override_active_url()}
2559      * may be of more use to you.
2560      *
2561      * @param string|int $key The key of the node you wish to receive.
2562      * @param int $type One of navigation_node::TYPE_*
2563      * @return navigation_node|false
2564      */
2565     public function find($key, $type) {
2566         if (!$this->initialised) {
2567             $this->initialise();
2568         }
2569         return parent::find($key, $type);
2570     }
2571 }
2572
2573 /**
2574  * The limited global navigation class used for the AJAX extension of the global
2575  * navigation class.
2576  *
2577  * The primary methods that are used in the global navigation class have been overriden
2578  * to ensure that only the relevant branch is generated at the root of the tree.
2579  * This can be done because AJAX is only used when the backwards structure for the
2580  * requested branch exists.
2581  * This has been done only because it shortens the amounts of information that is generated
2582  * which of course will speed up the response time.. because no one likes laggy AJAX.
2583  *
2584  * @package   core
2585  * @category  navigation
2586  * @copyright 2009 Sam Hemelryk
2587  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
2588  */
2589 class global_navigation_for_ajax extends global_navigation {
2590
2591     /** @var int used for determining what type of navigation_node::TYPE_* is being used */
2592     protected $branchtype;
2593
2594     /** @var int the instance id */
2595     protected $instanceid;
2596
2597     /** @var array Holds an array of expandable nodes */
2598     protected $expandable = array();
2599
2600     /**
2601      * Constructs the navigation for use in an AJAX request
2602      *
2603      * @param moodle_page $page moodle_page object
2604      * @param int $branchtype
2605      * @param int $id
2606      */
2607     public function __construct($page, $branchtype, $id) {
2608         $this->page = $page;
2609         $this->cache = new navigation_cache(NAVIGATION_CACHE_NAME);
2610         $this->children = new navigation_node_collection();
2611         $this->branchtype = $branchtype;
2612         $this->instanceid = $id;
2613         $this->initialise();
2614     }
2615     /**
2616      * Initialise the navigation given the type and id for the branch to expand.
2617      *
2618      * @return array An array of the expandable nodes
2619      */
2620     public function initialise() {
2621         global $CFG, $DB, $SITE;
2622
2623         if ($this->initialised || during_initial_install()) {
2624             return $this->expandable;
2625         }
2626         $this->initialised = true;
2627
2628         $this->rootnodes = array();
2629         $this->rootnodes['site']    = $this->add_course($SITE);
2630         $this->rootnodes['courses'] = $this->add(get_string('courses'), null, self::TYPE_ROOTNODE, null, 'courses');
2631
2632         // Branchtype will be one of navigation_node::TYPE_*
2633         switch ($this->branchtype) {
2634             case self::TYPE_CATEGORY :
2635                 $this->load_all_categories($this->instanceid);
2636                 $limit = 20;
2637                 if (!empty($CFG->navcourselimit)) {
2638                     $limit = (int)$CFG->navcourselimit;
2639                 }
2640                 $courses = $DB->get_records('course', array('category' => $this->instanceid), 'sortorder','*', 0, $limit);
2641                 foreach ($courses as $course) {
2642                     $this->add_course($course);
2643                 }
2644                 break;
2645             case self::TYPE_COURSE :
2646                 $course = $DB->get_record('course', array('id' => $this->instanceid), '*', MUST_EXIST);
2647                 require_course_login($course, true, null, false, true);
2648                 $this->page->set_context(get_context_instance(CONTEXT_COURSE, $course->id));
2649                 $coursenode = $this->add_course($course);
2650                 $this->add_course_essentials($coursenode, $course);
2651                 if ($this->format_display_course_content($course->format)) {
2652                     $this->load_course_sections($course, $coursenode);
2653                 }
2654                 break;
2655             case self::TYPE_SECTION :
2656                 $sql = 'SELECT c.*, cs.section AS sectionnumber
2657                         FROM {course} c
2658                         LEFT JOIN {course_sections} cs ON cs.course = c.id
2659                         WHERE cs.id = ?';
2660                 $course = $DB->get_record_sql($sql, array($this->instanceid), MUST_EXIST);
2661                 require_course_login($course, true, null, false, true);
2662                 $this->page->set_context(get_context_instance(CONTEXT_COURSE, $course->id));
2663                 $coursenode = $this->add_course($course);
2664                 $this->add_course_essentials($coursenode, $course);
2665                 $sections = $this->load_course_sections($course, $coursenode);
2666                 list($sectionarray, $activities) = $this->generate_sections_and_activities($course);
2667                 $this->load_section_activities($sections[$course->sectionnumber]->sectionnode, $course->sectionnumber, $activities);
2668                 break;
2669             case self::TYPE_ACTIVITY :
2670                 $sql = "SELECT c.*
2671                           FROM {course} c
2672                           JOIN {course_modules} cm ON cm.course = c.id
2673                          WHERE cm.id = :cmid";
2674                 $params = array('cmid' => $this->instanceid);
2675                 $course = $DB->get_record_sql($sql, $params, MUST_EXIST);
2676                 $modinfo = get_fast_modinfo($course);
2677                 $cm = $modinfo->get_cm($this->instanceid);
2678                 require_course_login($course, true, $cm, false, true);
2679                 $this->page->set_context(get_context_instance(CONTEXT_MODULE, $cm->id));
2680                 $coursenode = $this->load_course($course);
2681                 if ($course->id == SITEID) {
2682                     $modulenode = $this->load_activity($cm, $course, $coursenode->find($cm->id, self::TYPE_ACTIVITY));
2683                 } else {
2684                     $sections   = $this->load_course_sections($course, $coursenode);
2685                     list($sectionarray, $activities) = $this->generate_sections_and_activities($course);
2686                     $activities = $this->load_section_activities($sections[$cm->sectionnum]->sectionnode, $cm->sectionnum, $activities);
2687                     $modulenode = $this->load_activity($cm, $course, $activities[$cm->id]);
2688                 }
2689                 break;
2690             default:
2691                 throw new Exception('Unknown type');
2692                 return $this->expandable;
2693         }
2694
2695         if ($this->page->context->contextlevel == CONTEXT_COURSE && $this->page->context->instanceid != SITEID) {
2696             $this->load_for_user(null, true);
2697         }
2698
2699         $this->find_expandable($this->expandable);
2700         return $this->expandable;
2701     }
2702
2703     /**
2704      * Returns an array of expandable nodes
2705      * @return array
2706      */
2707     public function get_expandable() {
2708         return $this->expandable;
2709     }
2710 }
2711
2712 /**
2713  * Navbar class
2714  *
2715  * This class is used to manage the navbar, which is initialised from the navigation
2716  * object held by PAGE
2717  *
2718  * @package   core
2719  * @category  navigation
2720  * @copyright 2009 Sam Hemelryk
2721  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
2722  */
2723 class navbar extends navigation_node {
2724     /** @var bool A switch for whether the navbar is initialised or not */
2725     protected $initialised = false;
2726     /** @var mixed keys used to reference the nodes on the navbar */
2727     protected $keys = array();
2728     /** @var null|string content of the navbar */
2729     protected $content = null;
2730     /** @var moodle_page object the moodle page that this navbar belongs to */
2731     protected $page;
2732     /** @var bool A switch for whether to ignore the active navigation information */
2733     protected $ignoreactive = false;
2734     /** @var bool A switch to let us know if we are in the middle of an install */
2735     protected $duringinstall = false;
2736     /** @var bool A switch for whether the navbar has items */
2737     protected $hasitems = false;
2738     /** @var array An array of navigation nodes for the navbar */
2739     protected $items;
2740     /** @var array An array of child node objects */
2741     public $children = array();
2742     /** @var bool A switch for whether we want to include the root node in the navbar */
2743     public $includesettingsbase = false;
2744     /**
2745      * The almighty constructor
2746      *
2747      * @param moodle_page $page
2748      */
2749     public function __construct(moodle_page $page) {
2750         global $CFG;
2751         if (during_initial_install()) {
2752             $this->duringinstall = true;
2753             return false;
2754         }
2755         $this->page = $page;
2756         $this->text = get_string('home');
2757         $this->shorttext = get_string('home');
2758         $this->action = new moodle_url($CFG->wwwroot);
2759         $this->nodetype = self::NODETYPE_BRANCH;
2760         $this->type = self::TYPE_SYSTEM;
2761     }
2762
2763     /**
2764      * Quick check to see if the navbar will have items in.
2765      *
2766      * @return bool Returns true if the navbar will have items, false otherwise
2767      */
2768     public function has_items() {
2769         if ($this->duringinstall) {
2770             return false;
2771         } else if ($this->hasitems !== false) {
2772             return true;
2773         }
2774         $this->page->navigation->initialise($this->page);
2775
2776         $activenodefound = ($this->page->navigation->contains_active_node() ||
2777                             $this->page->settingsnav->contains_active_node());
2778
2779         $outcome = (count($this->children)>0 || (!$this->ignoreactive && $activenodefound));
2780         $this->hasitems = $outcome;
2781         return $outcome;
2782     }
2783
2784     /**
2785      * Turn on/off ignore active
2786      *
2787      * @param bool $setting
2788      */
2789     public function ignore_active($setting=true) {
2790         $this->ignoreactive = ($setting);
2791     }
2792
2793     /**
2794      * Gets a navigation node
2795      *
2796      * @param string|int $key for referencing the navbar nodes
2797      * @param int $type navigation_node::TYPE_*
2798      * @return navigation_node|bool
2799      */
2800     public function get($key, $type = null) {
2801         foreach ($this->children as &$child) {
2802             if ($child->key === $key && ($type == null || $type == $child->type)) {
2803                 return $child;
2804             }
2805         }
2806         return false;
2807     }
2808     /**
2809      * Returns an array of navigation_node's that make up the navbar.
2810      *
2811      * @return array
2812      */
2813     public function get_items() {
2814         $items = array();
2815         // Make sure that navigation is initialised
2816         if (!$this->has_items()) {
2817             return $items;
2818         }
2819         if ($this->items !== null) {
2820             return $this->items;
2821         }
2822
2823         if (count($this->children) > 0) {
2824             // Add the custom children
2825             $items = array_reverse($this->children);
2826         }
2827
2828         $navigationactivenode = $this->page->navigation->find_active_node();
2829         $settingsactivenode = $this->page->settingsnav->find_active_node();
2830
2831         // Check if navigation contains the active node
2832         if (!$this->ignoreactive) {
2833
2834             if ($navigationactivenode && $settingsactivenode) {
2835                 // Parse a combined navigation tree
2836                 while ($settingsactivenode && $settingsactivenode->parent !== null) {
2837                     if (!$settingsactivenode->mainnavonly) {
2838                         $items[] = $settingsactivenode;
2839                     }
2840                     $settingsactivenode = $settingsactivenode->parent;
2841                 }
2842                 if (!$this->includesettingsbase) {
2843                     // Removes the first node from the settings (root node) from the list
2844                     array_pop($items);
2845                 }
2846                 while ($navigationactivenode && $navigationactivenode->parent !== null) {
2847                     if (!$navigationactivenode->mainnavonly) {
2848                         $items[] = $navigationactivenode;
2849                     }
2850                     $navigationactivenode = $navigationactivenode->parent;
2851                 }
2852             } else if ($navigationactivenode) {
2853                 // Parse the navigation tree to get the active node
2854                 while ($navigationactivenode && $navigationactivenode->parent !== null) {
2855                     if (!$navigationactivenode->mainnavonly) {
2856                         $items[] = $navigationactivenode;
2857                     }
2858                     $navigationactivenode = $navigationactivenode->parent;
2859                 }
2860             } else if ($settingsactivenode) {
2861                 // Parse the settings navigation to get the active node
2862                 while ($settingsactivenode && $settingsactivenode->parent !== null) {
2863                     if (!$settingsactivenode->mainnavonly) {
2864                         $items[] = $settingsactivenode;
2865                     }
2866                     $settingsactivenode = $settingsactivenode->parent;
2867                 }
2868             }
2869         }
2870
2871         $items[] = new navigation_node(array(
2872             'text'=>$this->page->navigation->text,
2873             'shorttext'=>$this->page->navigation->shorttext,
2874             'key'=>$this->page->navigation->key,
2875             'action'=>$this->page->navigation->action
2876         ));
2877
2878         $this->items = array_reverse($items);
2879         return $this->items;
2880     }
2881
2882     /**
2883      * Add a new navigation_node to the navbar, overrides parent::add
2884      *
2885      * This function overrides {@link navigation_node::add()} so that we can change
2886      * the way nodes get added to allow us to simply call add and have the node added to the
2887      * end of the navbar
2888      *
2889      * @param string $text
2890      * @param string|moodle_url $action
2891      * @param int $type
2892      * @param string|int $key
2893      * @param string $shorttext
2894      * @param string $icon
2895      * @return navigation_node
2896      */
2897     public function add($text, $action=null, $type=self::TYPE_CUSTOM, $shorttext=null, $key=null, pix_icon $icon=null) {
2898         if ($this->content !== null) {
2899             debugging('Nav bar items must be printed before $OUTPUT->header() has been called', DEBUG_DEVELOPER);
2900         }
2901
2902         // Properties array used when creating the new navigation node
2903         $itemarray = array(
2904             'text' => $text,
2905             'type' => $type
2906         );
2907         // Set the action if one was provided
2908         if ($action!==null) {
2909             $itemarray['action'] = $action;
2910         }
2911         // Set the shorttext if one was provided
2912         if ($shorttext!==null) {
2913             $itemarray['shorttext'] = $shorttext;
2914         }
2915         // Set the icon if one was provided
2916         if ($icon!==null) {
2917             $itemarray['icon'] = $icon;
2918         }
2919         // Default the key to the number of children if not provided
2920         if ($key === null) {
2921             $key = count($this->children);
2922         }
2923         // Set the key
2924         $itemarray['key'] = $key;
2925         // Set the parent to this node
2926         $itemarray['parent'] = $this;
2927         // Add the child using the navigation_node_collections add method
2928         $this->children[] = new navigation_node($itemarray);
2929         return $this;
2930     }
2931 }
2932
2933 /**
2934  * Class used to manage the settings option for the current page
2935  *
2936  * This class is used to manage the settings options in a tree format (recursively)
2937  * and was created initially for use with the settings blocks.
2938  *
2939  * @package   core
2940  * @category  navigation
2941  * @copyright 2009 Sam Hemelryk
2942  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
2943  */
2944 class settings_navigation extends navigation_node {
2945     /** @var stdClass the current context */
2946     protected $context;
2947     /** @var moodle_page the moodle page that the navigation belongs to */
2948     protected $page;
2949     /** @var string contains administration section navigation_nodes */
2950     protected $adminsection;
2951     /** @var bool A switch to see if the navigation node is initialised */
2952     protected $initialised = false;
2953     /** @var array An array of users that the nodes can extend for. */
2954     protected $userstoextendfor = array();
2955     /** @var navigation_cache **/
2956     protected $cache;
2957
2958     /**
2959      * Sets up the object with basic settings and preparse it for use
2960      *
2961      * @param moodle_page $page
2962      */
2963     public function __construct(moodle_page &$page) {
2964         if (during_initial_install()) {
2965             return false;
2966         }
2967         $this->page = $page;
2968         // Initialise the main navigation. It is most important that this is done
2969         // before we try anything
2970         $this->page->navigation->initialise();
2971         // Initialise the navigation cache
2972         $this->cache = new navigation_cache(NAVIGATION_CACHE_NAME);
2973         $this->children = new navigation_node_collection();
2974     }
2975     /**
2976      * Initialise the settings navigation based on the current context
2977      *
2978      * This function initialises the settings navigation tree for a given context
2979      * by calling supporting functions to generate major parts of the tree.
2980      *
2981      */
2982     public function initialise() {
2983         global $DB, $SESSION;
2984
2985         if (during_initial_install()) {
2986             return false;
2987         } else if ($this->initialised) {
2988             return true;
2989         }
2990         $this->id = 'settingsnav';
2991         $this->context = $this->page->context;
2992
2993         $context = $this->context;
2994         if ($context->contextlevel == CONTEXT_BLOCK) {
2995             $this->load_block_settings();
2996             $context = $context->get_parent_context();
2997         }
2998
2999         switch ($context->contextlevel) {
3000             case CONTEXT_SYSTEM:
3001                 if ($this->page->url->compare(new moodle_url('/admin/settings.php', array('section'=>'frontpagesettings')))) {
3002                     $this->load_front_page_settings(($context->id == $this->context->id));
3003                 }
3004                 break;
3005             case CONTEXT_COURSECAT:
3006                 $this->load_category_settings();
3007                 break;
3008             case CONTEXT_COURSE:
3009                 if ($this->page->course->id != SITEID) {
3010                     $this->load_course_settings(($context->id == $this->context->id));
3011                 } else {
3012                     $this->load_front_page_settings(($context->id == $this->context->id));
3013                 }
3014                 break;
3015             case CONTEXT_MODULE:
3016                 $this->load_module_settings();
3017                 $this->load_course_settings();
3018                 break;
3019             case CONTEXT_USER:
3020                 if ($this->page->course->id != SITEID) {
3021                     $this->load_course_settings();
3022                 }
3023                 break;
3024         }
3025
3026         $settings = $this->load_user_settings($this->page->course->id);
3027
3028         if (isloggedin() && !isguestuser() && (!property_exists($SESSION, 'load_navigation_admin') || $SESSION->load_navigation_admin)) {
3029             $admin = $this->load_administration_settings();
3030             $SESSION->load_navigation_admin = ($admin->has_children());
3031         } else {
3032             $admin = false;
3033         }
3034
3035         if ($context->contextlevel == CONTEXT_SYSTEM && $admin) {
3036             $admin->force_open();
3037         } else if ($context->contextlevel == CONTEXT_USER && $settings) {
3038             $settings->force_open();
3039         }
3040
3041         // Check if the user is currently logged in as another user
3042         if (session_is_loggedinas()) {
3043             // Get the actual user, we need this so we can display an informative return link
3044             $realuser = session_get_realuser();
3045             // Add the informative return to original user link
3046             $url = new moodle_url('/course/loginas.php',array('id'=>$this->page->course->id, 'return'=>1,'sesskey'=>sesskey()));
3047             $this->add(get_string('returntooriginaluser', 'moodle', fullname($realuser, true)), $url, self::TYPE_SETTING, null, null, new pix_icon('t/left', ''));
3048         }
3049
3050         foreach ($this->children as $key=>$node) {
3051             if ($node->nodetype != self::NODETYPE_BRANCH || $node->children->count()===0) {
3052                 $node->remove();
3053             }
3054         }
3055         $this->initialised = true;
3056     }
3057     /**
3058      * Override the parent function so that we can add preceeding hr's and set a
3059      * root node class against all first level element
3060      *
3061      * It does this by first calling the parent's add method {@link navigation_node::add()}
3062      * and then proceeds to use the key to set class and hr
3063      *
3064      * @param string $text text to be used for the link.
3065      * @param string|moodle_url $url url for the new node
3066      * @param int $type the type of node navigation_node::TYPE_*
3067      * @param string $shorttext
3068      * @param string|int $key a key to access the node by.
3069      * @param pix_icon $icon An icon that appears next to the node.
3070      * @return navigation_node with the new node added to it.
3071      */
3072     public function add($text, $url=null, $type=null, $shorttext=null, $key=null, pix_icon $icon=null) {
3073         $node = parent::add($text, $url, $type, $shorttext, $key, $icon);
3074         $node->add_class('root_node');
3075         return $node;
3076     }
3077
3078     /**
3079      * This function allows the user to add something to the start of the settings
3080      * navigation, which means it will be at the top of the settings navigation block
3081      *
3082      * @param string $text text to be used for the link.
3083      * @param string|moodle_url $url url for the new node
3084      * @param int $type the type of node navigation_node::TYPE_*
3085      * @param string $shorttext
3086      * @param string|int $key a key to access the node by.
3087      * @param pix_icon $icon An icon that appears next to the node.
3088      * @return navigation_node $node with the new node added to it.
3089      */
3090     public function prepend($text, $url=null, $type=null, $shorttext=null, $key=null, pix_icon $icon=null) {
3091         $children = $this->children;
3092         $childrenclass = get_class($children);
3093         $this->children = new $childrenclass;
3094         $node = $this->add($text, $url, $type, $shorttext, $key, $icon);
3095         foreach ($children as $child) {
3096             $this->children->add($child);
3097         }
3098         return $node;
3099     }
3100     /**
3101      * Load the site administration tree
3102      *
3103      * This function loads the site administration tree by using the lib/adminlib library functions
3104      *
3105      * @param navigation_node $referencebranch A reference to a branch in the settings
3106      *      navigation tree
3107      * @param part_of_admin_tree $adminbranch The branch to add, if null generate the admin
3108      *      tree and start at the beginning
3109      * @return mixed A key to access the admin tree by
3110      */
3111     protected function load_administration_settings(navigation_node $referencebranch=null, part_of_admin_tree $adminbranch=null) {
3112         global $CFG;
3113
3114         // Check if we are just starting to generate this navigation.
3115         if ($referencebranch === null) {
3116
3117             // Require the admin lib then get an admin structure
3118             if (!function_exists('admin_get_root')) {
3119                 require_once($CFG->dirroot.'/lib/adminlib.php');
3120             }
3121             $adminroot = admin_get_root(false, false);
3122             // This is the active section identifier
3123             $this->adminsection = $this->page->url->param('section');
3124
3125             // Disable the navigation from automatically finding the active node
3126             navigation_node::$autofindactive = false;
3127             $referencebranch = $this->add(get_string('administrationsite'), null, self::TYPE_SETTING, null, 'root');
3128             foreach ($adminroot->children as $adminbranch) {
3129                 $this->load_administration_settings($referencebranch, $adminbranch);
3130             }
3131             navigation_node::$autofindactive = true;
3132
3133             // Use the admin structure to locate the active page
3134             if (!$this->contains_active_node() && $current = $adminroot->locate($this->adminsection, true)) {
3135                 $currentnode = $this;
3136                 while (($pathkey = array_pop($current->path))!==null && $currentnode) {
3137                     $currentnode = $currentnode->get($pathkey);
3138                 }
3139                 if ($currentnode) {
3140                     $currentnode->make_active();
3141                 }
3142             } else {
3143                 $this->scan_for_active_node($referencebranch);
3144             }
3145             return $referencebranch;
3146         } else if ($adminbranch->check_access()) {
3147             // We have a reference branch that we can access and is not hidden `hurrah`
3148             // Now we need to display it and any children it may have
3149             $url = null;
3150             $icon = null;
3151             if ($adminbranch instanceof admin_settingpage) {
3152                 $url = new moodle_url('/'.$CFG->admin.'/settings.php', array('section'=>$adminbranch->name));
3153             } else if ($adminbranch instanceof admin_externalpage) {
3154                 $url = $adminbranch->url;
3155             } else if (!empty($CFG->linkadmincategories) && $adminbranch instanceof admin_category) {
3156                 $url = new moodle_url('/'.$CFG->admin.'/category.php', array('category' => $adminbranch->name));
3157             }
3158
3159             // Add the branch
3160             $reference = $referencebranch->add($adminbranch->visiblename, $url, self::TYPE_SETTING, null, $adminbranch->name, $icon);
3161
3162             if ($adminbranch->is_hidden()) {
3163                 if (($adminbranch instanceof admin_externalpage || $adminbranch instanceof admin_settingpage) && $adminbranch->name == $this->adminsection) {
3164                     $reference->add_class('hidden');
3165                 } else {
3166                     $reference->display = false;
3167                 }
3168             }
3169
3170             // Check if we are generating the admin notifications and whether notificiations exist
3171             if ($adminbranch->name === 'adminnotifications' && admin_critical_warnings_present()) {
3172                 $reference->add_class('criticalnotification');
3173             }
3174             // Check if this branch has children
3175             if ($reference && isset($adminbranch->children) && is_array($adminbranch->children) && count($adminbranch->children)>0) {
3176                 foreach ($adminbranch->children as $branch) {
3177                     // Generate the child branches as well now using this branch as the reference
3178                     $this->load_administration_settings($reference, $branch);
3179                 }
3180             } else {
3181                 $reference->icon = new pix_icon('i/settings', '');
3182             }
3183         }
3184     }
3185
3186     /**
3187      * This function recursivily scans nodes until it finds the active node or there
3188      * are no more nodes.
3189      * @param navigation_node $node
3190      */
3191     protected function scan_for_active_node(navigation_node $node) {
3192         if (!$node->check_if_active() && $node->children->count()>0) {
3193             foreach ($node->children as &$child) {
3194                 $this->scan_for_active_node($child);
3195             }
3196         }
3197     }
3198
3199     /**
3200      * Gets a navigation node given an array of keys that represent the path to
3201      * the desired node.
3202      *
3203      * @param array $path
3204      * @return navigation_node|false
3205      */
3206     protected function get_by_path(array $path) {
3207         $node = $this->get(array_shift($path));
3208         foreach ($path as $key) {
3209             $node->get($key);
3210         }
3211         return $node;
3212     }
3213
3214     /**
3215      * Generate the list of modules for the given course.
3216      *
3217      * @param stdClass $course The course to get modules for
3218      */
3219     protected function get_course_modules($course) {
3220         global $CFG;
3221         $mods = $modnames = $modnamesplural = $modnamesused = array();
3222         // This function is included when we include course/lib.php at the top
3223         // of this file
3224         get_all_mods($course->id, $mods, $modnames, $modnamesplural, $modnamesused);
3225         $resources = array();
3226         $activities = array();
3227         foreach($modnames as $modname=>$modnamestr) {
3228             if (!course_allowed_module($course, $modname)) {
3229                 continue;
3230             }
3231
3232             $libfile = "$CFG->dirroot/mod/$modname/lib.php";
3233             if (!file_exists($libfile)) {
3234                 continue;
3235             }
3236             include_once($libfile);
3237             $gettypesfunc =  $modname.'_get_types';
3238             if (function_exists($gettypesfunc)) {
3239                 $types = $gettypesfunc();
3240                 foreach($types as $type) {
3241                     if (!isset($type->modclass) || !isset($type->typestr)) {
3242                         debugging('Incorrect activity type in '.$modname);
3243                         continue;
3244                     }
3245                     if ($type->modclass == MOD_CLASS_RESOURCE) {
3246                         $resources[html_entity_decode($type->type)] = $type->typestr;
3247                     } else {
3248                         $activities[html_entity_decode($type->type)] = $type->typestr;
3249                     }
3250                 }
3251             } else {
3252                 $archetype = plugin_supports('mod', $modname, FEATURE_MOD_ARCHETYPE, MOD_ARCHETYPE_OTHER);
3253                 if ($archetype == MOD_ARCHETYPE_RESOURCE) {
3254                     $resources[$modname] = $modnamestr;
3255                 } else {
3256                     // all other archetypes are considered activity
3257                     $activities[$modname] = $modnamestr;
3258                 }
3259             }
3260         }
3261         return array($resources, $activities);
3262     }
3263
3264     /**
3265      * This function loads the course settings that are available for the user
3266      *
3267      * @param bool $forceopen If set to true the course node will be forced open
3268      * @return navigation_node|false
3269      */
3270     protected function load_course_settings($forceopen = false) {
3271         global $CFG;
3272
3273         $course = $this->page->course;
3274         $coursecontext = get_context_instance(CONTEXT_COURSE, $course->id);
3275
3276         // note: do not test if enrolled or viewing here because we need the enrol link in Course administration section
3277
3278         $coursenode = $this->add(get_string('courseadministration'), null, self::TYPE_COURSE, null, 'courseadmin');
3279         if ($forceopen) {
3280             $coursenode->force_open();
3281         }
3282
3283         if (has_capability('moodle/course:update', $coursecontext)) {
3284             // Add the turn on/off settings
3285
3286             if ($this->page->url->compare(new moodle_url('/course/view.php'), URL_MATCH_BASE)) {
3287                 // We are on the course page, retain the current page params e.g. section.
3288                 $url = clone($this->page->url);
3289                 $url->param('sesskey', sesskey());
3290             } else {
3291                 // Edit on the main course page.
3292                 $url = new moodle_url('/course/view.php', array('id'=>$course->id, 'sesskey'=>sesskey()));
3293             }
3294             if ($this->page->user_is_editing()) {
3295                 $url->param('edit', 'off');
3296                 $editstring = get_string('turneditingoff');
3297             } else {
3298                 $url->param('edit', 'on');
3299                 $editstring = get_string('turneditingon');
3300             }
3301             $coursenode->add($editstring, $url, self::TYPE_SETTING, null, null, new pix_icon('i/edit', ''));
3302
3303             if ($this->page->user_is_editing()) {
3304                 // Removed as per MDL-22732
3305                 // $this->add_course_editing_links($course);
3306             }
3307
3308             // Add the course settings link
3309             $url = new moodle_url('/course/edit.php', array('id'=>$course->id));
3310             $coursenode->add(get_string('editsettings'), $url, self::TYPE_SETTING, null, null, new pix_icon('i/settings', ''));
3311
3312             // Add the course completion settings link
3313             if ($CFG->enablecompletion && $course->enablecompletion) {
3314                 $url = new moodle_url('/course/completion.php', array('id'=>$course->id));
3315                 $coursenode->add(get_string('completion', 'completion'), $url, self::TYPE_SETTING, null, null, new pix_icon('i/settings', ''));
3316             }
3317         }
3318
3319         // add enrol nodes
3320         enrol_add_course_navigation($coursenode, $course);
3321
3322         // Manage filters
3323         if (has_capability('moodle/filter:manage', $coursecontext) && count(filter_get_available_in_context($coursecontext))>0) {
3324             $url = new moodle_url('/filter/manage.php', array('contextid'=>$coursecontext->id));
3325             $coursenode->add(get_string('filters', 'admin'), $url, self::TYPE_SETTING, null, null, new pix_icon('i/filter', ''));
3326         }
3327
3328         // Add view grade report is permitted
3329         $reportavailable = false;
3330         if (has_capability('moodle/grade:viewall', $coursecontext)) {
3331             $reportavailable = true;
3332         } else if (!empty($course->showgrades)) {
3333             $reports = get_plugin_list('gradereport');
3334             if (is_array($reports) && count($reports)>0) {     // Get all installed reports
3335                 arsort($reports); // user is last, we want to test it first
3336                 foreach ($reports as $plugin => $plugindir) {
3337                     if (has_capability('gradereport/'.$plugin.':view', $coursecontext)) {
3338                         //stop when the first visible plugin is found
3339                         $reportavailable = true;
3340                         break;
3341                     }
3342                 }
3343             }
3344         }
3345         if ($reportavailable) {
3346             $url = new moodle_url('/grade/report/index.php', array('id'=>$course->id));
3347             $gradenode = $coursenode->add(get_string('grades'), $url, self::TYPE_SETTING, null, 'grades', new pix_icon('i/grades', ''));
3348         }
3349
3350         //  Add outcome if permitted
3351         if (!empty($CFG->enableoutcomes) && has_capability('moodle/course:update', $coursecontext)) {
3352             $url = new moodle_url('/grade/edit/outcome/course.php', array('id'=>$course->id));
3353             $coursenode->add(get_string('outcomes', 'grades'), $url, self::TYPE_SETTING, null, 'outcomes', new pix_icon('i/outcomes', ''));
3354         }
3355
3356         // Backup this course
3357         if (has_capability('moodle/backup:backupcourse', $coursecontext)) {
3358             $url = new moodle_url('/backup/backup.php', array('id'=>$course->id));
3359             $coursenode->add(get_string('backup'), $url, self::TYPE_SETTING, null, 'backup', new pix_icon('i/backup', ''));
3360         }
3361
3362         // Restore to this course
3363         if (has_capability('moodle/restore:restorecourse', $coursecontext)) {
3364             $url = new moodle_url('/backup/restorefile.php', array('contextid'=>$coursecontext->id));
3365             $coursenode->add(get_string('restore'), $url, self::TYPE_SETTING, null, 'restore', new pix_icon('i/restore', ''));
3366         }
3367
3368         // Import data from other courses
3369         if (has_capability('moodle/restore:restoretargetimport', $coursecontext)) {
3370             $url = new moodle_url('/backup/import.php', array('id'=>$course->id));
3371             $coursenode->add(get_string('import'), $url, self::TYPE_SETTING, null, 'import', new pix_icon('i/restore', ''));
3372         }
3373
3374         // Publish course on a hub
3375         if (has_capability('moodle/course:publish', $coursecontext)) {
3376             $url = new moodle_url('/course/publish/index.php', array('id'=>$course->id));
3377             $coursenode->add(get_string('publish'), $url, self::TYPE_SETTING, null, 'publish', new pix_icon('i/publish', ''));
3378         }
3379
3380         // Reset this course
3381         if (has_capability('moodle/course:reset', $coursecontext)) {
3382             $url = new moodle_url('/course/reset.php', array('id'=>$course->id));
3383             $coursenode->add(get_string('reset'), $url, self::TYPE_SETTING, null, null, new pix_icon('i/return', ''));
3384         }
3385
3386         // Questions
3387         require_once($CFG->libdir . '/questionlib.php');
3388         question_extend_settings_navigation($coursenode, $coursecontext)->trim_if_empty();
3389
3390         if (has_capability('moodle/course:update', $coursecontext)) {
3391             // Repository Instances
3392             if (!$this->cache->cached('contexthasrepos'.$coursecontext->id)) {
3393                 require_once($CFG->dirroot . '/repository/lib.php');
3394                 $editabletypes = repository::get_editable_types($coursecontext);
3395                 $haseditabletypes = !empty($editabletypes);
3396                 unset($editabletypes);
3397                 $this->cache->set('contexthasrepos'.$coursecontext->id, $haseditabletypes);
3398             } else {
3399                 $haseditabletypes = $this->cache->{'contexthasrepos'.$coursecontext->id};
3400             }
3401             if ($haseditabletypes) {
3402                 $url = new moodle_url('/repository/manage_instances.php', array('contextid' => $coursecontext->id));
3403                 $coursenode->add(get_string('repositories'), $url, self::TYPE_SETTING, null, null, new pix_icon('i/repository', ''));
3404             }
3405         }
3406
3407         // Manage files
3408         if ($course->legacyfiles == 2 and has_capability('moodle/course:managefiles', $coursecontext)) {
3409             // hidden in new courses and courses where legacy files were turned off
3410             $url = new moodle_url('/files/index.php', array('contextid'=>$coursecontext->id));
3411             $coursenode->add(get_string('courselegacyfiles'), $url, self::TYPE_SETTING, null, 'coursefiles', new pix_icon('i/files', ''));
3412
3413         }
3414
3415         // Switch roles
3416         $roles = array();
3417         $assumedrole = $this->in_alternative_role();
3418         if ($assumedrole !== false) {
3419             $roles[0] = get_string('switchrolereturn');
3420         }
3421         if (has_capability('moodle/role:switchroles', $coursecontext)) {
3422             $availableroles = get_switchable_roles($coursecontext);
3423             if (is_array($availableroles)) {
3424                 foreach ($availableroles as $key=>$role) {
3425                     if ($assumedrole == (int)$key) {
3426                         continue;
3427                     }
3428                     $roles[$key] = $role;
3429                 }
3430             }
3431         }
3432         if (is_array($roles) && count($roles)>0) {
3433             $switchroles = $this->add(get_string('switchroleto'));
3434             if ((count($roles)==1 && array_key_exists(0, $roles))|| $assumedrole!==false) {
3435                 $switchroles->force_open();
3436             }
3437             $returnurl = $this->page->url;
3438             $returnurl->param('sesskey', sesskey());
3439             foreach ($roles as $key => $name) {
3440                 $url = new moodle_url('/course/switchrole.php', array('id'=>$course->id,'sesskey'=>sesskey(), 'switchrole'=>$key, 'returnurl'=>$returnurl->out(false)));
3441                 $switchroles->add($name, $url, self::TYPE_SETTING, null, $key, new pix_icon('i/roles', ''));
3442             }
3443         }
3444         // Return we are done
3445         return $coursenode;
3446     }
3447
3448     /**
3449      * Adds branches and links to the settings navigation to add course activities
3450      * and resources.
3451      *
3452      * @param stdClass $course
3453      */
3454     protected function add_course_editing_links($course) {
3455         global $CFG;
3456
3457         require_once($CFG->dirroot.'/course/lib.php');
3458
3459         // Add `add` resources|activities branches
3460         $structurefile = $CFG->dirroot.'/course/format/'.$course->format.'/lib.php';
3461         if (file_exists($structurefile)) {
3462             require_once($structurefile);
3463             $requestkey = call_user_func('callback_'.$course->format.'_request_key');
3464             $formatidentifier = optional_param($requestkey, 0, PARAM_INT);
3465         } else {
3466             $requestkey = get_string('section');
3467             $formatidentifier = optional_param($requestkey, 0, PARAM_INT);
3468         }
3469
3470         $sections = get_all_sections($course->id);
3471
3472         $addresource = $this->add(get_string('addresource'));
3473         $addactivity = $this->add(get_string('addactivity'));
3474         if ($formatidentifier!==0) {
3475             $addresource->force_open();
3476             $addactivity->force_open();
3477         }
3478
3479         $this->get_course_modules($course);
3480
3481         foreach ($sections as $section) {
3482             if ($formatidentifier !== 0 && $section->section != $formatidentifier) {
3483                 continue;
3484             }
3485             $sectionurl = new moodle_url('/course/view.php', array('id'=>$course->id, $requestkey=>$section->section));
3486             if ($section->section == 0) {
3487                 $sectionresources = $addresource->add(get_string('course'), $sectionurl, self::TYPE_SETTING);
3488                 $sectionactivities = $addactivity->add(get_string('course'), $sectionurl, self::TYPE_SETTING);
3489             } else {
3490                 $sectionname = get_section_name($course, $section);
3491                 $sectionresources = $addresource->add($sectionname, $sectionurl, self::TYPE_SETTING);
3492                 $sectionactivities = $addactivity->add($sectionname, $sectionurl, self::TYPE_SETTING);
3493             }
3494             foreach ($resources as $value=>$resource) {
3495                 $url = new moodle_url('/course/mod.php', array('id'=>$course->id, 'sesskey'=>sesskey(), 'section'=>$section->section));
3496                 $pos = strpos($value, '&type=');
3497                 if ($pos!==false) {
3498                     $url->param('add', textlib::substr($value, 0,$pos));
3499                     $url->param('type', textlib::substr($value, $pos+6));
3500                 } else {
3501                     $url->param('add', $value);
3502                 }
3503                 $sectionresources->add($resource, $url, self::TYPE_SETTING);
3504             }
3505             $subbranch = false;
3506             foreach ($activities as $activityname=>$activity) {
3507                 if ($activity==='--') {
3508                     $subbranch = false;
3509                     continue;
3510                 }
3511                 if (strpos($activity, '--')===0) {
3512                     $subbranch = $sectionactivities->add(trim($activity, '-'));
3513                     continue;
3514                 }
3515                 $url = new moodle_url('/course/mod.php', array('id'=>$course->id, 'sesskey'=>sesskey(), 'section'=>$section->section));
3516                 $pos = strpos($activityname, '&type=');
3517                 if ($pos!==false) {
3518                     $url->param('add', textlib::substr($activityname, 0,$pos));
3519                     $url->param('type', textlib::substr($activityname, $pos+6));
3520                 } else {
3521                     $url->param('add', $activityname);
3522                 }
3523                 if ($subbranch !== false) {
3524                     $subbranch->add($activity, $url, self::TYPE_SETTING);
3525                 } else {
3526                     $sectionactivities->add($activity, $url, self::TYPE_SETTING);
3527                 }
3528             }
3529         }
3530     }
3531
3532     /**
3533      * This function calls the module function to inject module settings into the
3534      * settings navigation tree.
3535      *
3536      * This only gets called if there is a corrosponding function in the modules
3537      * lib file.
3538      *
3539      * For examples mod/forum/lib.php {@link forum_extend_settings_navigation()}
3540      *
3541      * @return navigation_node|false
3542      */
3543     protected function load_module_settings() {
3544         global $CFG;
3545
3546         if (!$this->page->cm && $this->context->contextlevel == CONTEXT_MODULE && $this->context->instanceid) {
3547             $cm = get_coursemodule_from_id(false, $this->context->instanceid, 0, false, MUST_EXIST);
3548             $this->page->set_cm($cm, $this->page->course);
3549         }
3550
3551         $file = $CFG->dirroot.'/mod/'.$this->page->activityname.'/lib.php';
3552         if (file_exists($file)) {
3553             require_once($file);
3554         }
3555
3556         $modulenode = $this->add(get_string('pluginadministration', $this->page->activityname));
3557         $modulenode->force_open();
3558
3559         // Settings for the module
3560         if (has_capability('moodle/course:manageactivities', $this->page->cm->context)) {
3561             $url = new moodle_url('/course/modedit.php', array('update' => $this->page->cm->id, 'return' => true, 'sesskey' => sesskey()));
3562             $modulenode->add(get_string('editsettings'), $url, navigation_node::TYPE_SETTING, null, 'modedit');
3563         }
3564         // Assign local roles
3565         if (count(get_assignable_roles($this->page->cm->context))>0) {
3566             $url = new moodle_url('/'.$CFG->admin.'/roles/assign.php', array('contextid'=>$this->page->cm->context->id));
3567             $modulenode->add(get_string('localroles', 'role'), $url, self::TYPE_SETTING, null, 'roleassign');
3568         }
3569         // Override roles
3570         if (has_capability('moodle/role:review', $this->page->cm->context) or count(get_overridable_roles($this->page->cm->context))>0) {
3571             $url = new moodle_url('/'.$CFG->admin.'/roles/permissions.php', array('contextid'=>$this->page->cm->context->id));
3572             $modulenode->add(get_string('permissions', 'role'), $url, self::TYPE_SETTING, null, 'roleoverride');
3573         }
3574         // Check role permissions
3575         if (has_any_capability(array('moodle/role:assign', 'moodle/role:safeoverride','moodle/role:override', 'moodle/role:assign'), $this->page->cm->context)) {
3576             $url = new moodle_url('/'.$CFG->admin.'/roles/check.php', array('contextid'=>$this->page->cm->context->id));
3577             $modulenode->add(get_string('checkpermissions', 'role'), $url, self::TYPE_SETTING, null, 'rolecheck');
3578         }
3579         // Manage filters
3580         if (has_capability('moodle/filter:manage', $this->page->cm->context) && count(filter_get_available_in_context($this->page->cm->context))>0) {
3581             $url = new moodle_url('/filter/manage.php', array('contextid'=>$this->page->cm->context->id));
3582             $modulenode->add(get_string('filters', 'admin'), $url, self::TYPE_SETTING, null, 'filtermanage');
3583         }
3584         // Add reports
3585         $reports = get_plugin_list_with_function('report', 'extend_navigation_module', 'lib.php');
3586         foreach ($reports as $reportfunction) {
3587             $reportfunction($modulenode, $this->page->cm);
3588         }
3589         // Add a backup link
3590         $featuresfunc = $this->page->activityname.'_supports';
3591         if (function_exists($featuresfunc) && $featuresfunc(FEATURE_BACKUP_MOODLE2) && has_capability('moodle/backup:backupactivity', $this->page->cm->context)) {
3592             $url = new moodle_url('/backup/backup.php', array('id'=>$this->page->cm->course, 'cm'=>$this->page->cm->id));
3593             $modulenode->add(get_string('backup'), $url, self::TYPE_SETTING, null, 'backup');
3594         }
3595
3596         // Restore this activity
3597         $featuresfunc = $this->page->activityname.'_supports';
3598         if (function_exists($featuresfunc) && $featuresfunc(FEATURE_BACKUP_MOODLE2) && has_capability('moodle/restore:restoreactivity', $this->page->cm->context)) {
3599             $url = new moodle_url('/backup/restorefile.php', array('contextid'=>$this->page->cm->context->id));
3600             $modulenode->add(get_string('restore'), $url, self::TYPE_SETTING, null, 'restore');
3601         }
3602
3603         // Allow the active advanced grading method plugin to append its settings
3604         $featuresfunc = $this->page->activityname.'_supports';
3605         if (function_exists($featuresfunc) && $featuresfunc(FEATURE_ADVANCED_GRADING) && has_capability('moodle/grade:managegradingforms', $this->page->cm->context)) {
3606             require_once($CFG->dirroot.'/grade/grading/lib.php');
3607             $gradingman = get_grading_manager($this->page->cm->context, $this->page->activityname);
3608             $gradingman->extend_settings_navigation($this, $modulenode);
3609         }
3610
3611         $function = $this->page->activityname.'_extend_settings_navigation';
3612         if (!function_exists($function)) {
3613             return $modulenode;
3614         }
3615
3616         $function($this, $modulenode);
3617
3618         // Remove the module node if there are no children
3619         if (empty($modulenode->children)) {
3620             $modulenode->remove();
3621         }
3622
3623         return $modulenode;
3624     }
3625
3626     /**
3627      * Loads the user settings block of the settings nav
3628      *
3629      * This function is simply works out the userid and whether we need to load
3630      * just the current users profile settings, or the current user and the user the
3631      * current user is viewing.
3632      *
3633      * This function has some very ugly code to work out the user, if anyone has
3634      * any bright ideas please feel free to intervene.
3635      *
3636      * @param int $courseid The course id of the current course
3637      * @return navigation_node|false
3638      */
3639     protected function load_user_settings($courseid=SITEID) {
3640         global $USER, $CFG;
3641
3642         if (isguestuser() || !isloggedin()) {
3643             return false;
3644         }
3645
3646         $navusers = $this->page->navigation->get_extending_users();
3647
3648         if (count($this->userstoextendfor) > 0 || count($navusers) > 0) {
3649             $usernode = null;
3650             foreach ($this->userstoextendfor as $userid) {
3651                 if ($userid == $USER->id) {
3652                     continue;
3653                 }
3654                 $node = $this->generate_user_settings($courseid, $userid, 'userviewingsettings');
3655                 if (is_null($usernode)) {
3656                     $usernode = $node;
3657                 }
3658             }
3659             foreach ($navusers as $user) {
3660                 if ($user->id == $USER->id) {
3661                     continue;
3662                 }
3663                 $node = $this->generate_user_settings($courseid, $user->id, 'userviewingsettings');
3664                 if (is_null($usernode)) {
3665                     $usernode = $node;
3666                 }
3667             }
3668             $this->generate_user_settings($courseid, $USER->id);
3669         } else {
3670             $usernode = $this->generate_user_settings($courseid, $USER->id);
3671         }
3672         return $usernode;
3673     }
3674
3675     /**
3676      * Extends the settings navigation for the given user.
3677      *
3678      * Note: This method gets called automatically if you call
3679      * $PAGE->navigation->extend_for_user($userid)
3680      *
3681      * @param int $userid
3682      */
3683     public function extend_for_user($userid) {
3684         global $CFG;
3685
3686         if (!in_array($userid, $this->userstoextendfor)) {
3687             $this->userstoextendfor[] = $userid;
3688             if ($this->initialised) {
3689                 $this->generate_user_settings($this->page->course->id, $userid, 'userviewingsettings');
3690                 $children = array();
3691                 foreach ($this->children as $child) {
3692                     $children[] = $child;
3693                 }
3694                 array_unshift($children, array_pop($children));
3695                 $this->children = new navigation_node_collection();
3696                 foreach ($children as $child) {
3697                     $this->children->add($child);
3698                 }
3699             }
3700         }
3701     }
3702
3703     /**
3704      * This function gets called by {@link settings_navigation::load_user_settings()} and actually works out
3705      * what can be shown/done
3706      *
3707      * @param int $courseid The current course' id
3708      * @param int $userid The user id to load for
3709      * @param string $gstitle The string to pass to get_string for the branch title
3710      * @return navigation_node|false
3711      */
3712     protected function generate_user_settings($courseid, $userid, $gstitle='usercurrentsettings') {
3713         global $DB, $CFG, $USER, $SITE;
3714
3715         if ($courseid != SITEID) {
3716             if (!empty($this->page->course->id) && $this->page->course->id == $courseid) {
3717                 $course = $this->page->course;
3718             } else {
3719                 $select = context_helper::get_preload_record_columns_sql('ctx');
3720                 $sql = "SELECT c.*, $select
3721                           FROM {course} c
3722                           JOIN {context} ctx ON c.id = ctx.instanceid
3723                          WHERE c.id = :courseid AND ctx.contextlevel = :contextlevel";
3724                 $params = array('courseid' => $courseid, 'contextlevel' => CONTEXT_COURSE);
3725                 $course = $DB->get_record_sql($sql, $params, MUST_EXIST);
3726                 context_helper::preload_from_record($course);
3727             }
3728         } else {
3729             $course = $SITE;
3730         }
3731
3732         $coursecontext = get_context_instance(CONTEXT_COURSE, $course->id);   // Course context
3733         $systemcontext   = get_system_context();
3734         $currentuser = ($USER->id == $userid);
3735
3736         if ($currentuser) {
3737             $user = $USER;
3738             $usercontext = get_context_instance(CONTEXT_USER, $user->id);       // User context
3739         } else {
3740             $select = context_helper::get_preload_record_columns_sql('ctx');
3741             $sql = "SELECT u.*, $select
3742                       FROM {user} u
3743                       JOIN {context} ctx ON u.id = ctx.instanceid
3744                      WHERE u.id = :userid AND ctx.contextlevel = :contextlevel";
3745             $params = array('userid' => $userid, 'contextlevel' => CONTEXT_USER);
3746             $user = $DB->get_record_sql($sql, $params, IGNORE_MISSING);
3747             if (!$user) {
3748                 return false;
3749             }
3750             context_helper::preload_from_record($user);
3751
3752             // Check that the user can view the profile
3753             $usercontext = get_context_instance(CONTEXT_USER, $user->id); // User context
3754             $canviewuser = has_capability('moodle/user:viewdetails', $usercontext);
3755
3756             if ($course->id == SITEID) {
3757                 if ($CFG->forceloginforprofiles && !has_coursecontact_role($user->id) && !$canviewuser) {  // Reduce possibility of "browsing" userbase at site level
3758                     // Teachers can browse and be browsed at site level. If not forceloginforprofiles, allow access (bug #4366)
3759                     return false;
3760                 }
3761             } else {
3762                 $canviewusercourse = has_capability('moodle/user:viewdetails', $coursecontext);
3763                 $canaccessallgroups = has_capability('moodle/site:accessallgroups', $coursecontext);
3764                 if ((!$canviewusercourse && !$canviewuser) || !can_access_course($course, $user->id)) {
3765                     return false;
3766                 }
3767                 if (!$canaccessallgroups && groups_get_course_groupmode($course) == SEPARATEGROUPS) {
3768                     // If groups are in use, make sure we can see that group
3769                     return false;
3770                 }
3771             }
3772         }
3773
3774         $fullname = fullname($user, has_capability('moodle/site:viewfullnames', $this->page->context));
3775
3776         $key = $gstitle;
3777         if ($gstitle != 'usercurrentsettings') {
3778             $key .= $userid;
3779         }
3780
3781         // Add a user setting branch
3782         $usersetting = $this->add(get_string($gstitle, 'moodle', $fullname), null, self::TYPE_CONTAINER, null, $key);
3783         $usersetting->id = 'usersettings';
3784         if ($this->page->context->contextlevel == CONTEXT_USER && $this->page->context->instanceid == $user->id) {
3785             // Automatically start by making it active
3786             $usersetting->make_active();
3787         }
3788
3789         // Check if the user has been deleted
3790         if ($user->deleted) {
3791             if (!has_capability('moodle/user:update', $coursecontext)) {
3792                 // We can't edit the user so just show the user deleted message
3793                 $usersetting->add(get_string('userdeleted'), null, self::TYPE_SETTING);
3794             } else {
3795                 // We can edit the user so show the user deleted message and link it to the profile
3796                 if ($course->id == SITEID) {
3797                     $profileurl = new moodle_url('/user/profile.php', array('id'=>$user->id));
3798                 } else {
3799                     $profileurl = new moodle_url('/user/view.php', array('id'=>$user->id, 'course'=>$course->id));
3800                 }
3801                 $usersetting->add(get_string('userdeleted'), $profileurl, self::TYPE_SETTING);
3802             }
3803             return true;
3804         }
3805
3806         $userauthplugin = false;
3807         if (!empty($user->auth)) {
3808