3 // This file is part of Moodle - http://moodle.org/
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.
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.
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/>.
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
24 * @subpackage navigation
25 * @copyright 2009 Sam Hemelryk
26 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
29 defined('MOODLE_INTERNAL') ||
die();
32 * The name that will be used to separate the navigation cache within SESSION
34 define('NAVIGATION_CACHE_NAME', 'navigation');
37 * This class is used to represent a node in a navigation tree
39 * This class is used to represent a node in a navigation tree within Moodle,
40 * the tree could be one of global navigation, settings navigation, or the navbar.
41 * Each node can be one of two types either a Leaf (default) or a branch.
42 * When a node is first created it is created as a leaf, when/if children are added
43 * the node then becomes a branch.
46 * @subpackage navigation
47 * @copyright 2009 Sam Hemelryk
48 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
50 class navigation_node
implements renderable
{
51 /** @var int Used to identify this node a leaf (default) 0 */
52 const NODETYPE_LEAF
= 0;
53 /** @var int Used to identify this node a branch, happens with children 1 */
54 const NODETYPE_BRANCH
= 1;
55 /** @var null Unknown node type null */
56 const TYPE_UNKNOWN
= null;
57 /** @var int System node type 0 */
58 const TYPE_ROOTNODE
= 0;
59 /** @var int System node type 1 */
60 const TYPE_SYSTEM
= 1;
61 /** @var int Category node type 10 */
62 const TYPE_CATEGORY
= 10;
63 /** @var int Course node type 20 */
64 const TYPE_COURSE
= 20;
65 /** @var int Course Structure node type 30 */
66 const TYPE_SECTION
= 30;
67 /** @var int Activity node type, e.g. Forum, Quiz 40 */
68 const TYPE_ACTIVITY
= 40;
69 /** @var int Resource node type, e.g. Link to a file, or label 50 */
70 const TYPE_RESOURCE
= 50;
71 /** @var int A custom node type, default when adding without specifing type 60 */
72 const TYPE_CUSTOM
= 60;
73 /** @var int Setting node type, used only within settings nav 70 */
74 const TYPE_SETTING
= 70;
75 /** @var int Setting node type, used only within settings nav 80 */
77 /** @var int Setting node type, used for containers of no importance 90 */
78 const TYPE_CONTAINER
= 90;
80 /** @var int Parameter to aid the coder in tracking [optional] */
82 /** @var string|int The identifier for the node, used to retrieve the node */
84 /** @var string The text to use for the node */
86 /** @var string Short text to use if requested [optional] */
87 public $shorttext = null;
88 /** @var string The title attribute for an action if one is defined */
90 /** @var string A string that can be used to build a help button */
91 public $helpbutton = null;
92 /** @var moodle_url|action_link|null An action for the node (link) */
93 public $action = null;
94 /** @var pix_icon The path to an icon to use for this node */
96 /** @var int See TYPE_* constants defined for this class */
97 public $type = self
::TYPE_UNKNOWN
;
98 /** @var int See NODETYPE_* constants defined for this class */
99 public $nodetype = self
::NODETYPE_LEAF
;
100 /** @var bool If set to true the node will be collapsed by default */
101 public $collapse = false;
102 /** @var bool If set to true the node will be expanded by default */
103 public $forceopen = false;
104 /** @var array An array of CSS classes for the node */
105 public $classes = array();
106 /** @var navigation_node_collection An array of child nodes */
107 public $children = array();
108 /** @var bool If set to true the node will be recognised as active */
109 public $isactive = false;
110 /** @var bool If set to true the node will be dimmed */
111 public $hidden = false;
112 /** @var bool If set to false the node will not be displayed */
113 public $display = true;
114 /** @var bool If set to true then an HR will be printed before the node */
115 public $preceedwithhr = false;
116 /** @var bool If set to true the the navigation bar should ignore this node */
117 public $mainnavonly = false;
118 /** @var bool If set to true a title will be added to the action no matter what */
119 public $forcetitle = false;
120 /** @var navigation_node A reference to the node parent, you should never set this directly you should always call set_parent */
121 public $parent = null;
122 /** @var bool Override to not display the icon even if one is provided **/
123 public $hideicon = false;
125 protected $namedtypes = array(0=>'system',10=>'category',20=>'course',30=>'structure',40=>'activity',50=>'resource',60=>'custom',70=>'setting', 80=>'user');
126 /** @var moodle_url */
127 protected static $fullmeurl = null;
128 /** @var bool toogles auto matching of active node */
129 public static $autofindactive = true;
132 * Constructs a new navigation_node
134 * @param array|string $properties Either an array of properties or a string to use
135 * as the text for the node
137 public function __construct($properties) {
138 if (is_array($properties)) {
139 // Check the array for each property that we allow to set at construction.
140 // text - The main content for the node
141 // shorttext - A short text if required for the node
142 // icon - The icon to display for the node
143 // type - The type of the node
144 // key - The key to use to identify the node
145 // parent - A reference to the nodes parent
146 // action - The action to attribute to this node, usually a URL to link to
147 if (array_key_exists('text', $properties)) {
148 $this->text
= $properties['text'];
150 if (array_key_exists('shorttext', $properties)) {
151 $this->shorttext
= $properties['shorttext'];
153 if (!array_key_exists('icon', $properties)) {
154 $properties['icon'] = new pix_icon('i/navigationitem', 'moodle');
156 $this->icon
= $properties['icon'];
157 if ($this->icon
instanceof pix_icon
) {
158 if (empty($this->icon
->attributes
['class'])) {
159 $this->icon
->attributes
['class'] = 'navicon';
161 $this->icon
->attributes
['class'] .= ' navicon';
164 if (array_key_exists('type', $properties)) {
165 $this->type
= $properties['type'];
167 $this->type
= self
::TYPE_CUSTOM
;
169 if (array_key_exists('key', $properties)) {
170 $this->key
= $properties['key'];
172 // This needs to happen last because of the check_if_active call that occurs
173 if (array_key_exists('action', $properties)) {
174 $this->action
= $properties['action'];
175 if (is_string($this->action
)) {
176 $this->action
= new moodle_url($this->action
);
178 if (self
::$autofindactive) {
179 $this->check_if_active();
182 if (array_key_exists('parent', $properties)) {
183 $this->set_parent($properties['parent']);
185 } else if (is_string($properties)) {
186 $this->text
= $properties;
188 if ($this->text
=== null) {
189 throw new coding_exception('You must set the text for the node when you create it.');
191 // Default the title to the text
192 $this->title
= $this->text
;
193 // Instantiate a new navigation node collection for this nodes children
194 $this->children
= new navigation_node_collection();
198 * Checks if this node is the active node.
200 * This is determined by comparing the action for the node against the
201 * defined URL for the page. A match will see this node marked as active.
203 * @param int $strength One of URL_MATCH_EXACT, URL_MATCH_PARAMS, or URL_MATCH_BASE
206 public function check_if_active($strength=URL_MATCH_EXACT
) {
207 global $FULLME, $PAGE;
208 // Set fullmeurl if it hasn't already been set
209 if (self
::$fullmeurl == null) {
210 if ($PAGE->has_set_url()) {
211 self
::override_active_url(new moodle_url($PAGE->url
));
213 self
::override_active_url(new moodle_url($FULLME));
217 // Compare the action of this node against the fullmeurl
218 if ($this->action
instanceof moodle_url
&& $this->action
->compare(self
::$fullmeurl, $strength)) {
219 $this->make_active();
226 * This sets the URL that the URL of new nodes get compared to when locating
229 * The active node is the node that matches the URL set here. By default this
230 * is either $PAGE->url or if that hasn't been set $FULLME.
232 * @param moodle_url $url The url to use for the fullmeurl.
234 public static function override_active_url(moodle_url
$url) {
235 // Clone the URL, in case the calling script changes their URL later.
236 self
::$fullmeurl = new moodle_url($url);
240 * Creates a navigation node, ready to add it as a child using add_node
241 * function. (The created node needs to be added before you can use it.)
242 * @param string $text
243 * @param moodle_url|action_link $action
245 * @param string $shorttext
246 * @param string|int $key
247 * @param pix_icon $icon
248 * @return navigation_node
250 public static function create($text, $action=null, $type=self
::TYPE_CUSTOM
,
251 $shorttext=null, $key=null, pix_icon
$icon=null) {
252 // Properties array used when creating the new navigation node
257 // Set the action if one was provided
258 if ($action!==null) {
259 $itemarray['action'] = $action;
261 // Set the shorttext if one was provided
262 if ($shorttext!==null) {
263 $itemarray['shorttext'] = $shorttext;
265 // Set the icon if one was provided
267 $itemarray['icon'] = $icon;
270 $itemarray['key'] = $key;
271 // Construct and return
272 return new navigation_node($itemarray);
276 * Adds a navigation node as a child of this node.
278 * @param string $text
279 * @param moodle_url|action_link $action
281 * @param string $shorttext
282 * @param string|int $key
283 * @param pix_icon $icon
284 * @return navigation_node
286 public function add($text, $action=null, $type=self
::TYPE_CUSTOM
, $shorttext=null, $key=null, pix_icon
$icon=null) {
288 $childnode = self
::create($text, $action, $type, $shorttext, $key, $icon);
290 // Add the child to end and return
291 return $this->add_node($childnode);
295 * Adds a navigation node as a child of this one, given a $node object
296 * created using the create function.
297 * @param navigation_node $childnode Node to add
298 * @param int|string $key The key of a node to add this before. If not
299 * specified, adds at end of list
300 * @return navigation_node The added node
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
;
307 // Set the parent to this node
308 $childnode->set_parent($this);
310 // Default the key to the number of children if not provided
311 if ($childnode->key
=== null) {
312 $childnode->key
= $this->children
->count();
315 // Add the child using the navigation_node_collections add method
316 $node = $this->children
->add($childnode, $beforekey);
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
;
324 // If this node is hidden mark it's children as hidden also
326 $node->hidden
= true;
328 // Return added node (reference returned by $this->children->add()
333 * Return a list of all the keys of all the child nodes.
334 * @return array the keys.
336 public function get_children_key_list() {
337 return $this->children
->get_key_list();
341 * Searches for a node of the given type with the given key.
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.
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
351 public function find($key, $type) {
352 return $this->children
->find($key, $type);
356 * Get ths child of this node that has the given key + (optional) type.
358 * If you are looking for a node and want to search all children + thier children
359 * then please use the find method instead.
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
365 public function get($key, $type=null) {
366 return $this->children
->get($key, $type);
374 public function remove() {
375 return $this->parent
->children
->remove($this->key
, $this->type
);
379 * Checks if this node has or could have any children
381 * @return bool Returns true if it has children or could have (by AJAX expansion)
383 public function has_children() {
384 return ($this->nodetype
=== navigation_node
::NODETYPE_BRANCH ||
$this->children
->count()>0);
388 * Marks this node as active and forces it open.
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 {@see 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.
395 public function make_active() {
396 $this->isactive
= true;
397 $this->add_class('active_tree_node');
399 if ($this->parent
!== null) {
400 $this->parent
->make_inactive();
405 * Marks a node as inactive and recusised back to the base of the tree
406 * doing the same to all parents.
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();
417 * Forces this node to be open and at the same time forces open all
418 * parents until the root node.
422 public function force_open() {
423 $this->forceopen
= true;
424 if ($this->parent
!== null) {
425 $this->parent
->force_open();
430 * Adds a CSS class to this node.
432 * @param string $class
435 public function add_class($class) {
436 if (!in_array($class, $this->classes
)) {
437 $this->classes
[] = $class;
443 * Removes a CSS class from this node.
445 * @param string $class
446 * @return bool True if the class was successfully removed.
448 public function remove_class($class) {
449 if (in_array($class, $this->classes
)) {
450 $key = array_search($class,$this->classes
);
452 unset($this->classes
[$key]);
460 * Sets the title for this node and forces Moodle to utilise it.
461 * @param string $title
463 public function title($title) {
464 $this->title
= $title;
465 $this->forcetitle
= true;
469 * Resets the page specific information on this node if it is being unserialised.
471 public function __wakeup(){
472 $this->forceopen
= false;
473 $this->isactive
= false;
474 $this->remove_class('active_tree_node');
478 * Checks if this node or any of its children contain the active node.
484 public function contains_active_node() {
485 if ($this->isactive
) {
488 foreach ($this->children
as $child) {
489 if ($child->isactive ||
$child->contains_active_node()) {
498 * Finds the active node.
500 * Searches this nodes children plus all of the children for the active node
501 * and returns it if found.
505 * @return navigation_node|false
507 public function find_active_node() {
508 if ($this->isactive
) {
511 foreach ($this->children
as &$child) {
512 $outcome = $child->find_active_node();
513 if ($outcome !== false) {
522 * Searches all children for the best matching active node
523 * @return navigation_node|false
525 public function search_for_active_node() {
526 if ($this->check_if_active(URL_MATCH_BASE
)) {
529 foreach ($this->children
as &$child) {
530 $outcome = $child->search_for_active_node();
531 if ($outcome !== false) {
540 * Gets the content for this node.
542 * @param bool $shorttext If true shorttext is used rather than the normal text
545 public function get_content($shorttext=false) {
546 if ($shorttext && $this->shorttext
!==null) {
547 return format_string($this->shorttext
);
549 return format_string($this->text
);
554 * Gets the title to use for this node.
558 public function get_title() {
559 if ($this->forcetitle ||
$this->action
!= null){
567 * Gets the CSS class to add to this node to describe its type
571 public function get_css_type() {
572 if (array_key_exists($this->type
, $this->namedtypes
)) {
573 return 'type_'.$this->namedtypes
[$this->type
];
575 return 'type_unknown';
579 * Finds all nodes that are expandable by AJAX
581 * @param array $expandable An array by reference to populate with expandable nodes.
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
);
590 $child->find_expandable($expandable);
595 * Finds all nodes of a given type (recursive)
597 * @param int $type On of navigation_node::TYPE_*
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);
610 * Removes this node if it is empty
612 public function trim_if_empty() {
613 if ($this->children
->count() == 0) {
619 * Creates a tab representation of this nodes children that can be used
620 * with print_tabs to produce the tabs on a page.
622 * call_user_func_array('print_tabs', $node->get_tabs_array());
624 * @param array $inactive
625 * @param bool $return
626 * @return array Array (tabs, selected, inactive, activated, return)
628 public function get_tabs_array(array $inactive=array(), $return=false) {
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
;
642 $rows[] = new tabobject($child->key
, $child->action
, $child->get_content(), $child->get_title());
645 $selected = $node->key
;
649 return array(array($tabs, $rows), $selected, $inactive, $activated, $return);
653 * Sets the parent for this node and if this node is active ensures that the tree is properly
656 * @param navigation_node $parent
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();
672 * Navigation node collection
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
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.
682 * @package moodlecore
683 * @subpackage navigation
684 * @copyright 2010 Sam Hemelryk
685 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
687 class navigation_node_collection
implements IteratorAggregate
{
689 * A multidimensional array to where the first key is the type and the second
690 * key is the nodes key.
693 protected $collection = array();
695 * An array that contains references to nodes in the same order they were added.
696 * This is maintained as a progressive array.
699 protected $orderedcollection = array();
701 * A reference to the last node that was added to the collection
702 * @var navigation_node
704 protected $last = null;
706 * The total number of items added to this array.
709 protected $count = 0;
712 * Adds a navigation node to the collection
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
719 public function add(navigation_node
$node, $beforekey=null) {
724 // First check we have a 2nd dimension for this type
725 if (!array_key_exists($type, $this->orderedcollection
)) {
726 $this->orderedcollection
[$type] = array();
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
);
733 // Find the key to add before
734 $newindex = $this->count
;
736 if ($beforekey !== null) {
737 foreach ($this->collection
as $index => $othernode) {
738 if ($othernode->key
=== $beforekey) {
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
);
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;
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];
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];
765 // Reorder the array by index if needed
767 ksort($this->collection
);
770 // Return the reference to the now added node
775 * Return a list of all the keys of all the nodes.
776 * @return array the keys.
778 public function get_key_list() {
780 foreach ($this->collection
as $node) {
781 $keys[] = $node->key
;
787 * Fetches a node from this collection.
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
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];
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) {
811 * Searches for a node with matching key and type.
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.
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
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];
826 $nodes = $this->getIterator();
827 // Search immediate children first
828 foreach ($nodes as &$node) {
829 if ($node->key
=== $key && ($type === null ||
$type === $node->type
)) {
833 // Now search each childs children
834 foreach ($nodes as &$node) {
835 $result = $node->children
->find($key, $type);
836 if ($result !== false) {
845 * Fetches the last node that was added to this collection
847 * @return navigation_node
849 public function last() {
854 * Fetches all nodes of a given type from this collection
856 public function type($type) {
857 if (!array_key_exists($type, $this->orderedcollection
)) {
858 $this->orderedcollection
[$type] = array();
860 return $this->orderedcollection
[$type];
863 * Removes the node with the given key and type from the collection
865 * @param string|int $key
869 public function remove($key, $type=null) {
870 $child = $this->get($key, $type);
871 if ($child !== false) {
872 foreach ($this->collection
as $colkey => $node) {
873 if ($node->key
== $key && $node->type
== $type) {
874 unset($this->collection
[$colkey]);
878 unset($this->orderedcollection
[$child->type
][$child->key
]);
886 * Gets the number of nodes in this collection
888 * This option uses an internal count rather than counting the actual options to avoid
889 * a performance hit through the count function.
893 public function count() {
897 * Gets an array iterator for the collection.
899 * This is required by the IteratorAggregator interface and is used by routines
900 * such as the foreach loop.
902 * @return ArrayIterator
904 public function getIterator() {
905 return new ArrayIterator($this->collection
);
910 * The global navigation class used for... the global navigation
912 * This class is used by PAGE to store the global navigation for the site
913 * and is then used by the settings nav and navbar to save on processing and DB calls
917 * <li><b>{@link lib/pagelib.php}</b> {@link moodle_page::initialise_theme_and_output()}<li>
918 * <li><b>{@link lib/ajax/getnavbranch.php}</b> Called by ajax<li>
921 * @package moodlecore
922 * @subpackage navigation
923 * @copyright 2009 Sam Hemelryk
924 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
926 class global_navigation
extends navigation_node
{
928 * The Moodle page this navigation object belongs to.
933 protected $initialised = false;
935 protected $mycourses = array();
937 protected $rootnodes = array();
939 protected $showemptysections = false;
941 protected $showcategories = null;
943 protected $extendforuser = array();
944 /** @var navigation_cache */
947 protected $addedcourses = array();
949 protected $addedcategories = array();
951 protected $expansionlimit = 0;
953 protected $useridtouseforparentchecks = 0;
956 * Constructs a new global navigation
958 * @param moodle_page $page The page this navigation object belongs to
960 public function __construct(moodle_page
$page) {
961 global $CFG, $SITE, $USER;
963 if (during_initial_install()) {
967 if (get_home_page() == HOMEPAGE_SITE
) {
968 // We are using the site home for the root element
971 'type' => navigation_node
::TYPE_SYSTEM
,
972 'text' => get_string('home'),
973 'action' => new moodle_url('/')
976 // We are using the users my moodle for the root element
979 'type' => navigation_node
::TYPE_SYSTEM
,
980 'text' => get_string('myhome'),
981 'action' => new moodle_url('/my/')
985 // Use the parents consturctor.... good good reuse
986 parent
::__construct($properties);
988 // Initalise and set defaults
990 $this->forceopen
= true;
991 $this->cache
= new navigation_cache(NAVIGATION_CACHE_NAME
);
995 * Mutator to set userid to allow parent to see child's profile
996 * page navigation. See MDL-25805 for initial issue. Linked to it
997 * is an issue explaining why this is a REALLY UGLY HACK thats not
1000 * @param int $userid userid of profile page that parent wants to navigate around.
1002 public function set_userid_for_parent_checks($userid) {
1003 $this->useridtouseforparentchecks
= $userid;
1008 * Initialises the navigation object.
1010 * This causes the navigation object to look at the current state of the page
1011 * that it is associated with and then load the appropriate content.
1013 * This should only occur the first time that the navigation structure is utilised
1014 * which will normally be either when the navbar is called to be displayed or
1015 * when a block makes use of it.
1019 public function initialise() {
1020 global $CFG, $SITE, $USER, $DB;
1021 // Check if it has alread been initialised
1022 if ($this->initialised ||
during_initial_install()) {
1025 $this->initialised
= true;
1027 // Set up the five base root nodes. These are nodes where we will put our
1028 // content and are as follows:
1029 // site: Navigation for the front page.
1030 // myprofile: User profile information goes here.
1031 // mycourses: The users courses get added here.
1032 // courses: Additional courses are added here.
1033 // users: Other users information loaded here.
1034 $this->rootnodes
= array();
1035 if (get_home_page() == HOMEPAGE_SITE
) {
1036 // The home element should be my moodle because the root element is the site
1037 if (isloggedin() && !isguestuser()) { // Makes no sense if you aren't logged in
1038 $this->rootnodes
['home'] = $this->add(get_string('myhome'), new moodle_url('/my/'), self
::TYPE_SETTING
, null, 'home');
1041 // The home element should be the site because the root node is my moodle
1042 $this->rootnodes
['home'] = $this->add(get_string('sitehome'), new moodle_url('/'), self
::TYPE_SETTING
, null, 'home');
1043 if ($CFG->defaulthomepage
== HOMEPAGE_MY
) {
1044 // We need to stop automatic redirection
1045 $this->rootnodes
['home']->action
->param('redirect', '0');
1048 $this->rootnodes
['site'] = $this->add_course($SITE);
1049 $this->rootnodes
['myprofile'] = $this->add(get_string('myprofile'), null, self
::TYPE_USER
, null, 'myprofile');
1050 $this->rootnodes
['mycourses'] = $this->add(get_string('mycourses'), null, self
::TYPE_ROOTNODE
, null, 'mycourses');
1051 $this->rootnodes
['courses'] = $this->add(get_string('courses'), null, self
::TYPE_ROOTNODE
, null, 'courses');
1052 $this->rootnodes
['users'] = $this->add(get_string('users'), null, self
::TYPE_ROOTNODE
, null, 'users');
1054 // Fetch all of the users courses.
1056 if (!empty($CFG->navcourselimit
)) {
1057 $limit = $CFG->navcourselimit
;
1060 $mycourses = enrol_get_my_courses(NULL, 'visible DESC,sortorder ASC', $limit);
1061 $showallcourses = (count($mycourses) == 0 ||
!empty($CFG->navshowallcourses
));
1062 $showcategories = ($showallcourses && $this->show_categories());
1063 $issite = ($this->page
->course
->id
!= SITEID
);
1064 $ismycourse = (array_key_exists($this->page
->course
->id
, $mycourses));
1066 // Check if any courses were returned.
1067 if (count($mycourses) > 0) {
1068 // Add all of the users courses to the navigation
1069 foreach ($mycourses as $course) {
1070 $course->coursenode
= $this->add_course($course, false, true);
1074 if ($showallcourses) {
1076 $this->load_all_courses();
1079 // We always load the frontpage course to ensure it is available without
1080 // JavaScript enabled.
1081 $frontpagecourse = $this->load_course($SITE);
1082 $this->add_front_page_course_essentials($frontpagecourse, $SITE);
1084 $canviewcourseprofile = true;
1086 // Next load context specific content into the navigation
1087 switch ($this->page
->context
->contextlevel
) {
1088 case CONTEXT_SYSTEM
:
1089 // This has already been loaded we just need to map the variable
1090 $coursenode = $frontpagecourse;
1091 $this->load_all_categories(null, $showcategories);
1093 case CONTEXT_COURSECAT
:
1094 // This has already been loaded we just need to map the variable
1095 $coursenode = $frontpagecourse;
1096 $this->load_all_categories($this->page
->context
->instanceid
, $showcategories);
1098 case CONTEXT_BLOCK
:
1099 case CONTEXT_COURSE
:
1100 // Load the course associated with the page into the navigation
1101 $course = $this->page
->course
;
1102 if ($showcategories && !$issite && !$ismycourse) {
1103 $this->load_all_categories($course->category
, $showcategories);
1105 $coursenode = $this->load_course($course);
1107 // If the course wasn't added then don't try going any further.
1109 $canviewcourseprofile = false;
1113 // If the user is not enrolled then we only want to show the
1114 // course node and not populate it.
1115 $coursecontext = get_context_instance(CONTEXT_COURSE
, $course->id
);
1117 // Not enrolled, can't view, and hasn't switched roles
1118 if (!can_access_course($coursecontext)) {
1119 // TODO: very ugly hack - do not force "parents" to enrol into course their child is enrolled in,
1120 // this hack has been propagated from user/view.php to display the navigation node. (MDL-25805)
1122 if ($this->useridtouseforparentchecks
) {
1123 if ($this->useridtouseforparentchecks
!= $USER->id
) {
1124 $usercontext = get_context_instance(CONTEXT_USER
, $this->useridtouseforparentchecks
, MUST_EXIST
);
1125 if ($DB->record_exists('role_assignments', array('userid' => $USER->id
, 'contextid' => $usercontext->id
))
1126 and has_capability('moodle/user:viewdetails', $usercontext)) {
1133 $coursenode->make_active();
1134 $canviewcourseprofile = false;
1138 // Add the essentials such as reports etc...
1139 $this->add_course_essentials($coursenode, $course);
1140 if ($this->format_display_course_content($course->format
)) {
1141 // Load the course sections
1142 $sections = $this->load_course_sections($course, $coursenode);
1144 if (!$coursenode->contains_active_node() && !$coursenode->search_for_active_node()) {
1145 $coursenode->make_active();
1148 case CONTEXT_MODULE
:
1149 $course = $this->page
->course
;
1150 $cm = $this->page
->cm
;
1152 if ($showcategories && !$issite && !$ismycourse) {
1153 $this->load_all_categories($course->category
, $showcategories);
1156 // Load the course associated with the page into the navigation
1157 $coursenode = $this->load_course($course);
1159 // If the course wasn't added then don't try going any further.
1161 $canviewcourseprofile = false;
1165 // If the user is not enrolled then we only want to show the
1166 // course node and not populate it.
1167 $coursecontext = get_context_instance(CONTEXT_COURSE
, $course->id
);
1168 if (!can_access_course($coursecontext)) {
1169 $coursenode->make_active();
1170 $canviewcourseprofile = false;
1174 $this->add_course_essentials($coursenode, $course);
1175 // Load the course sections into the page
1176 $sections = $this->load_course_sections($course, $coursenode);
1177 if ($course->id
!= SITEID
) {
1178 // Find the section for the $CM associated with the page and collect
1179 // its section number.
1180 if (isset($cm->sectionnum
)) {
1181 $cm->sectionnumber
= $cm->sectionnum
;
1183 foreach ($sections as $section) {
1184 if ($section->id
== $cm->section
) {
1185 $cm->sectionnumber
= $section->section
;
1191 // Load all of the section activities for the section the cm belongs to.
1192 if (isset($cm->sectionnumber
) and !empty($sections[$cm->sectionnumber
])) {
1193 list($sectionarray, $activityarray) = $this->generate_sections_and_activities($course);
1194 $activities = $this->load_section_activities($sections[$cm->sectionnumber
]->sectionnode
, $cm->sectionnumber
, $activityarray);
1196 $activities = array();
1197 if ($activity = $this->load_stealth_activity($coursenode, get_fast_modinfo($course))) {
1198 // "stealth" activity from unavailable section
1199 $activities[$cm->id
] = $activity;
1203 $activities = array();
1204 $activities[$cm->id
] = $coursenode->get($cm->id
, navigation_node
::TYPE_ACTIVITY
);
1206 if (!empty($activities[$cm->id
])) {
1207 // Finally load the cm specific navigaton information
1208 $this->load_activity($cm, $course, $activities[$cm->id
]);
1209 // Check if we have an active ndoe
1210 if (!$activities[$cm->id
]->contains_active_node() && !$activities[$cm->id
]->search_for_active_node()) {
1211 // And make the activity node active.
1212 $activities[$cm->id
]->make_active();
1215 //TODO: something is wrong, what to do? (Skodak)
1219 $course = $this->page
->course
;
1220 if ($course->id
!= SITEID
) {
1221 if ($showcategories && !$issite && !$ismycourse) {
1222 $this->load_all_categories($course->category
, $showcategories);
1224 // Load the course associated with the user into the navigation
1225 $coursenode = $this->load_course($course);
1227 // If the course wasn't added then don't try going any further.
1229 $canviewcourseprofile = false;
1233 // If the user is not enrolled then we only want to show the
1234 // course node and not populate it.
1235 $coursecontext = get_context_instance(CONTEXT_COURSE
, $course->id
);
1236 if (!can_access_course($coursecontext)) {
1237 $coursenode->make_active();
1238 $canviewcourseprofile = false;
1241 $this->add_course_essentials($coursenode, $course);
1242 $sections = $this->load_course_sections($course, $coursenode);
1248 if (!empty($CFG->navcourselimit
)) {
1249 $limit = $CFG->navcourselimit
;
1251 if ($showcategories) {
1252 $categories = $this->find_all_of_type(self
::TYPE_CATEGORY
);
1253 foreach ($categories as &$category) {
1254 if ($category->children
->count() >= $limit) {
1255 $url = new moodle_url('/course/category.php', array('id'=>$category->key
));
1256 $category->add(get_string('viewallcourses'), $url, self
::TYPE_SETTING
);
1259 } else if ($this->rootnodes
['courses']->children
->count() >= $limit) {
1260 $this->rootnodes
['courses']->add(get_string('viewallcoursescategories'), new moodle_url('/course/index.php'), self
::TYPE_SETTING
);
1263 // Load for the current user
1264 $this->load_for_user();
1265 if ($this->page
->context
->contextlevel
>= CONTEXT_COURSE
&& $this->page
->context
->instanceid
!= SITEID
&& $canviewcourseprofile) {
1266 $this->load_for_user(null, true);
1268 // Load each extending user into the navigation.
1269 foreach ($this->extendforuser
as $user) {
1270 if ($user->id
!= $USER->id
) {
1271 $this->load_for_user($user);
1275 // Give the local plugins a chance to include some navigation if they want.
1276 foreach (get_list_of_plugins('local') as $plugin) {
1277 if (!file_exists($CFG->dirroot
.'/local/'.$plugin.'/lib.php')) {
1280 require_once($CFG->dirroot
.'/local/'.$plugin.'/lib.php');
1281 $function = $plugin.'_extends_navigation';
1282 if (function_exists($function)) {
1287 // Remove any empty root nodes
1288 foreach ($this->rootnodes
as $node) {
1289 // Dont remove the home node
1290 if ($node->key
!== 'home' && !$node->has_children()) {
1295 if (!$this->contains_active_node()) {
1296 $this->search_for_active_node();
1299 // If the user is not logged in modify the navigation structure as detailed
1300 // in {@link http://docs.moodle.org/dev/Navigation_2.0_structure}
1301 if (!isloggedin()) {
1302 $activities = clone($this->rootnodes
['site']->children
);
1303 $this->rootnodes
['site']->remove();
1304 $children = clone($this->children
);
1305 $this->children
= new navigation_node_collection();
1306 foreach ($activities as $child) {
1307 $this->children
->add($child);
1309 foreach ($children as $child) {
1310 $this->children
->add($child);
1317 * Returns true is courses should be shown within categories on the navigation.
1321 protected function show_categories() {
1323 if ($this->showcategories
=== null) {
1324 $this->showcategories
= !empty($CFG->navshowcategories
) && $DB->count_records('course_categories') > 1;
1326 return $this->showcategories
;
1330 * Checks the course format to see whether it wants the navigation to load
1331 * additional information for the course.
1333 * This function utilises a callback that can exist within the course format lib.php file
1334 * The callback should be a function called:
1335 * callback_{formatname}_display_content()
1336 * It doesn't get any arguments and should return true if additional content is
1337 * desired. If the callback doesn't exist we assume additional content is wanted.
1339 * @param string $format The course format
1342 protected function format_display_course_content($format) {
1344 $formatlib = $CFG->dirroot
.'/course/format/'.$format.'/lib.php';
1345 if (file_exists($formatlib)) {
1346 require_once($formatlib);
1347 $displayfunc = 'callback_'.$format.'_display_content';
1348 if (function_exists($displayfunc) && !$displayfunc()) {
1349 return $displayfunc();
1356 * Loads of the the courses in Moodle into the navigation.
1358 * @global moodle_database $DB
1359 * @param string|array $categoryids Either a string or array of category ids to load courses for
1360 * @return array An array of navigation_node
1362 protected function load_all_courses($categoryids=null) {
1363 global $CFG, $DB, $USER;
1365 if ($categoryids !== null) {
1366 if (is_array($categoryids)) {
1367 list ($categoryselect, $params) = $DB->get_in_or_equal($categoryids, SQL_PARAMS_NAMED
, 'catid');
1369 $categoryselect = '= :categoryid';
1370 $params = array('categoryid', $categoryids);
1372 $params['siteid'] = SITEID
;
1373 $categoryselect = ' AND c.category '.$categoryselect;
1375 $params = array('siteid' => SITEID
);
1376 $categoryselect = '';
1379 list($ccselect, $ccjoin) = context_instance_preload_sql('c.id', CONTEXT_COURSE
, 'ctx');
1380 list($courseids, $courseparams) = $DB->get_in_or_equal(array_keys($this->addedcourses
) +
array(SITEID
), SQL_PARAMS_NAMED
, 'lcourse', false);
1381 $sql = "SELECT c.id, c.sortorder, c.visible, c.fullname, c.shortname, c.category, cat.path AS categorypath $ccselect
1384 LEFT JOIN {course_categories} cat ON cat.id=c.category
1385 WHERE c.id {$courseids} {$categoryselect}
1386 ORDER BY c.sortorder ASC";
1388 if (!empty($CFG->navcourselimit
)) {
1389 $limit = $CFG->navcourselimit
;
1391 $courses = $DB->get_records_sql($sql, $params +
$courseparams, 0, $limit);
1393 $coursenodes = array();
1394 foreach ($courses as $course) {
1395 context_instance_preload($course);
1396 $coursenodes[$course->id
] = $this->add_course($course);
1398 return $coursenodes;
1402 * Loads all categories (top level or if an id is specified for that category)
1404 * @param int $categoryid The category id to load or null/0 to load all base level categories
1405 * @param bool $showbasecategories If set to true all base level categories will be loaded as well
1406 * as the requested category and any parent categories.
1409 protected function load_all_categories($categoryid = null, $showbasecategories = false) {
1412 // Check if this category has already been loaded
1413 if ($categoryid !== null && array_key_exists($categoryid, $this->addedcategories
) && $this->addedcategories
[$categoryid]->children
->count() > 0) {
1414 return $this->addedcategories
[$categoryid];
1417 $coursestoload = array();
1418 if (empty($categoryid)) { // can be 0
1419 // We are going to load all of the first level categories (categories without parents)
1420 $categories = $DB->get_records('course_categories', array('parent'=>'0'), 'sortorder ASC, id ASC');
1421 } else if (array_key_exists($categoryid, $this->addedcategories
)) {
1422 // The category itself has been loaded already so we just need to ensure its subcategories
1424 list($sql, $params) = $DB->get_in_or_equal(array_keys($this->addedcategories
), SQL_PARAMS_NAMED
, 'parent', false);
1425 if ($showbasecategories) {
1426 // We need to include categories with parent = 0 as well
1428 FROM {course_categories} cc
1429 WHERE (parent = :categoryid OR parent = 0) AND
1431 ORDER BY depth DESC, sortorder ASC, id ASC";
1434 FROM {course_categories} cc
1435 WHERE parent = :categoryid AND
1437 ORDER BY depth DESC, sortorder ASC, id ASC";
1439 $params['categoryid'] = $categoryid;
1440 $categories = $DB->get_records_sql($sql, $params);
1441 if (count($categories) == 0) {
1442 // There are no further categories that require loading.
1446 // This category hasn't been loaded yet so we need to fetch it, work out its category path
1447 // and load this category plus all its parents and subcategories
1448 $category = $DB->get_record('course_categories', array('id' => $categoryid), 'path', MUST_EXIST
);
1449 $coursestoload = explode('/', trim($category->path
, '/'));
1450 list($select, $params) = $DB->get_in_or_equal($coursestoload);
1451 $select = 'id '.$select.' OR parent '.$select;
1452 if ($showbasecategories) {
1453 $select .= ' OR parent = 0';
1455 $params = array_merge($params, $params);
1456 $categories = $DB->get_records_select('course_categories', $select, $params, 'sortorder');
1459 // Now we have an array of categories we need to add them to the navigation.
1460 while (!empty($categories)) {
1461 $category = reset($categories);
1462 if (array_key_exists($category->id
, $this->addedcategories
)) {
1464 } else if ($category->parent
== '0') {
1465 $this->add_category($category, $this->rootnodes
['courses']);
1466 } else if (array_key_exists($category->parent
, $this->addedcategories
)) {
1467 $this->add_category($category, $this->addedcategories
[$category->parent
]);
1469 // This category isn't in the navigation and niether is it's parent (yet).
1470 // We need to go through the category path and add all of its components in order.
1471 $path = explode('/', trim($category->path
, '/'));
1472 foreach ($path as $catid) {
1473 if (!array_key_exists($catid, $this->addedcategories
)) {
1474 // This category isn't in the navigation yet so add it.
1475 $subcategory = $categories[$catid];
1476 if ($subcategory->parent
== '0') {
1477 // Yay we have a root category - this likely means we will now be able
1478 // to add categories without problems.
1479 $this->add_category($subcategory, $this->rootnodes
['courses']);
1480 } else if (array_key_exists($subcategory->parent
, $this->addedcategories
)) {
1481 // The parent is in the category (as we'd expect) so add it now.
1482 $this->add_category($subcategory, $this->addedcategories
[$subcategory->parent
]);
1483 // Remove the category from the categories array.
1484 unset($categories[$catid]);
1486 // We should never ever arrive here - if we have then there is a bigger
1488 throw new coding_exception('Category path order is incorrect and/or there are missing categories');
1493 // Remove the category from the categories array now that we know it has been added.
1494 unset($categories[$category->id
]);
1496 // Check if there are any categories to load.
1497 if (count($coursestoload) > 0) {
1498 $this->load_all_courses($coursestoload);
1503 * Adds a structured category to the navigation in the correct order/place
1505 * @param stdClass $category
1506 * @param navigation_node $parent
1508 protected function add_category(stdClass
$category, navigation_node
$parent) {
1509 if (array_key_exists($category->id
, $this->addedcategories
)) {
1512 $url = new moodle_url('/course/category.php', array('id' => $category->id
));
1513 $context = get_context_instance(CONTEXT_COURSECAT
, $category->id
);
1514 $categoryname = format_string($category->name
, true, array('context' => $context));
1515 $categorynode = $parent->add($categoryname, $url, self
::TYPE_CATEGORY
, $categoryname, $category->id
);
1516 if (empty($category->visible
)) {
1517 if (has_capability('moodle/category:viewhiddencategories', get_system_context())) {
1518 $categorynode->hidden
= true;
1520 $categorynode->display
= false;
1523 $this->addedcategories
[$category->id
] = &$categorynode;
1527 * Loads the given course into the navigation
1529 * @param stdClass $course
1530 * @return navigation_node
1532 protected function load_course(stdClass
$course) {
1533 if ($course->id
== SITEID
) {
1534 return $this->rootnodes
['site'];
1535 } else if (array_key_exists($course->id
, $this->addedcourses
)) {
1536 return $this->addedcourses
[$course->id
];
1538 return $this->add_course($course);
1543 * Loads all of the courses section into the navigation.
1545 * This function utilisies a callback that can be implemented within the course
1546 * formats lib.php file to customise the navigation that is generated at this
1547 * point for the course.
1549 * By default (if not defined) the method {@see load_generic_course_sections} is
1552 * @param stdClass $course Database record for the course
1553 * @param navigation_node $coursenode The course node within the navigation
1554 * @return array Array of navigation nodes for the section with key = section id
1556 protected function load_course_sections(stdClass
$course, navigation_node
$coursenode) {
1558 $structurefile = $CFG->dirroot
.'/course/format/'.$course->format
.'/lib.php';
1559 $structurefunc = 'callback_'.$course->format
.'_load_content';
1560 if (function_exists($structurefunc)) {
1561 return $structurefunc($this, $course, $coursenode);
1562 } else if (file_exists($structurefile)) {
1563 require_once $structurefile;
1564 if (function_exists($structurefunc)) {
1565 return $structurefunc($this, $course, $coursenode);
1567 return $this->load_generic_course_sections($course, $coursenode);
1570 return $this->load_generic_course_sections($course, $coursenode);
1575 * Generates an array of sections and an array of activities for the given course.
1577 * This method uses the cache to improve performance and avoid the get_fast_modinfo call
1579 * @param stdClass $course
1580 * @return array Array($sections, $activities)
1582 protected function generate_sections_and_activities(stdClass
$course) {
1584 require_once($CFG->dirroot
.'/course/lib.php');
1586 if (!$this->cache
->cached('course_sections_'.$course->id
) ||
!$this->cache
->cached('course_activites_'.$course->id
)) {
1587 $modinfo = get_fast_modinfo($course);
1588 $sections = array_slice(get_all_sections($course->id
), 0, $course->numsections+
1, true);
1590 $activities = array();
1592 foreach ($sections as $key => $section) {
1593 $sections[$key]->hasactivites
= false;
1594 if (!array_key_exists($section->section
, $modinfo->sections
)) {
1597 foreach ($modinfo->sections
[$section->section
] as $cmid) {
1598 $cm = $modinfo->cms
[$cmid];
1599 if (!$cm->uservisible
) {
1602 $activity = new stdClass
;
1603 $activity->section
= $section->section
;
1604 $activity->name
= $cm->name
;
1605 $activity->icon
= $cm->icon
;
1606 $activity->iconcomponent
= $cm->iconcomponent
;
1607 $activity->id
= $cm->id
;
1608 $activity->hidden
= (!$cm->visible
);
1609 $activity->modname
= $cm->modname
;
1610 $activity->nodetype
= navigation_node
::NODETYPE_LEAF
;
1611 $url = $cm->get_url();
1613 $activity->url
= null;
1614 $activity->display
= false;
1616 $activity->url
= $cm->get_url()->out();
1617 $activity->display
= true;
1618 if (self
::module_extends_navigation($cm->modname
)) {
1619 $activity->nodetype
= navigation_node
::NODETYPE_BRANCH
;
1622 $activities[$cmid] = $activity;
1623 $sections[$key]->hasactivites
= true;
1626 $this->cache
->set('course_sections_'.$course->id
, $sections);
1627 $this->cache
->set('course_activites_'.$course->id
, $activities);
1629 $sections = $this->cache
->{'course_sections_'.$course->id
};
1630 $activities = $this->cache
->{'course_activites_'.$course->id
};
1632 return array($sections, $activities);
1636 * Generically loads the course sections into the course's navigation.
1638 * @param stdClass $course
1639 * @param navigation_node $coursenode
1640 * @param string $courseformat The course format
1641 * @return array An array of course section nodes
1643 public function load_generic_course_sections(stdClass
$course, navigation_node
$coursenode, $courseformat='unknown') {
1644 global $CFG, $DB, $USER;
1645 require_once($CFG->dirroot
.'/course/lib.php');
1647 list($sections, $activities) = $this->generate_sections_and_activities($course);
1649 $namingfunction = 'callback_'.$courseformat.'_get_section_name';
1650 $namingfunctionexists = (function_exists($namingfunction));
1652 $viewhiddensections = has_capability('moodle/course:viewhiddensections', $this->page
->context
);
1654 $urlfunction = 'callback_'.$courseformat.'_get_section_url';
1655 if (empty($CFG->navlinkcoursesections
) ||
!function_exists($urlfunction)) {
1656 $urlfunction = null;
1659 $keyfunction = 'callback_'.$courseformat.'_request_key';
1660 $key = course_get_display($course->id
);
1661 if (defined('AJAX_SCRIPT') && AJAX_SCRIPT
== '0' && function_exists($keyfunction) && $this->page
->url
->compare(new moodle_url('/course/view.php'), URL_MATCH_BASE
)) {
1662 $key = optional_param($keyfunction(), $key, PARAM_INT
);
1665 $navigationsections = array();
1666 foreach ($sections as $sectionid => $section) {
1667 $section = clone($section);
1668 if ($course->id
== SITEID
) {
1669 $this->load_section_activities($coursenode, $section->section
, $activities);
1671 if ((!$viewhiddensections && !$section->visible
) ||
(!$this->showemptysections
&& !$section->hasactivites
)) {
1674 if ($namingfunctionexists) {
1675 $sectionname = $namingfunction($course, $section, $sections);
1677 $sectionname = get_string('section').' '.$section->section
;
1681 if (!empty($urlfunction)) {
1682 $url = $urlfunction($course->id
, $section->section
);
1684 $sectionnode = $coursenode->add($sectionname, $url, navigation_node
::TYPE_SECTION
, null, $section->id
);
1685 $sectionnode->nodetype
= navigation_node
::NODETYPE_BRANCH
;
1686 $sectionnode->hidden
= (!$section->visible
);
1687 if ($key != '0' && $section->section
!= '0' && $section->section
== $key && $this->page
->context
->contextlevel
!= CONTEXT_MODULE
&& $section->hasactivites
) {
1688 $sectionnode->make_active();
1689 $this->load_section_activities($sectionnode, $section->section
, $activities);
1691 $section->sectionnode
= $sectionnode;
1692 $navigationsections[$sectionid] = $section;
1695 return $navigationsections;
1698 * Loads all of the activities for a section into the navigation structure.
1700 * @todo 2.2 - $activities should always be an array and we should no longer check for it being a
1701 * course_modinfo object
1703 * @param navigation_node $sectionnode
1704 * @param int $sectionnumber
1705 * @param course_modinfo $modinfo Object returned from {@see get_fast_modinfo()}
1706 * @return array Array of activity nodes
1708 protected function load_section_activities(navigation_node
$sectionnode, $sectionnumber, $activities) {
1710 if ($activities instanceof course_modinfo
) {
1711 debugging('global_navigation::load_section_activities argument 3 should now recieve an array of activites. See that method for an example.', DEBUG_DEVELOPER
);
1712 list($sections, $activities) = $this->generate_sections_and_activities($activities->course
);
1715 $activitynodes = array();
1716 foreach ($activities as $activity) {
1717 if ($activity->section
!= $sectionnumber) {
1720 if ($activity->icon
) {
1721 $icon = new pix_icon($activity->icon
, get_string('modulename', $activity->modname
), $activity->iconcomponent
);
1723 $icon = new pix_icon('icon', get_string('modulename', $activity->modname
), $activity->modname
);
1725 $activitynode = $sectionnode->add(format_string($activity->name
), $activity->url
, navigation_node
::TYPE_ACTIVITY
, null, $activity->id
, $icon);
1726 $activitynode->title(get_string('modulename', $activity->modname
));
1727 $activitynode->hidden
= $activity->hidden
;
1728 $activitynode->display
= $activity->display
;
1729 $activitynode->nodetype
= $activity->nodetype
;
1730 $activitynodes[$activity->id
] = $activitynode;
1733 return $activitynodes;
1736 * Loads a stealth module from unavailable section
1737 * @param navigation_node $coursenode
1738 * @param stdClass $modinfo
1739 * @return navigation_node or null if not accessible
1741 protected function load_stealth_activity(navigation_node
$coursenode, $modinfo) {
1742 if (empty($modinfo->cms
[$this->page
->cm
->id
])) {
1745 $cm = $modinfo->cms
[$this->page
->cm
->id
];
1746 if (!$cm->uservisible
) {
1750 $icon = new pix_icon($cm->icon
, get_string('modulename', $cm->modname
), $cm->iconcomponent
);
1752 $icon = new pix_icon('icon', get_string('modulename', $cm->modname
), $cm->modname
);
1754 $url = $cm->get_url();
1755 $activitynode = $coursenode->add(format_string($cm->name
), $url, navigation_node
::TYPE_ACTIVITY
, null, $cm->id
, $icon);
1756 $activitynode->title(get_string('modulename', $cm->modname
));
1757 $activitynode->hidden
= (!$cm->visible
);
1759 // Don't show activities that don't have links!
1760 $activitynode->display
= false;
1761 } else if (self
::module_extends_navigation($cm->modname
)) {
1762 $activitynode->nodetype
= navigation_node
::NODETYPE_BRANCH
;
1764 return $activitynode;
1767 * Loads the navigation structure for the given activity into the activities node.
1769 * This method utilises a callback within the modules lib.php file to load the
1770 * content specific to activity given.
1772 * The callback is a method: {modulename}_extend_navigation()
1774 * * {@see forum_extend_navigation()}
1775 * * {@see workshop_extend_navigation()}
1777 * @param cm_info|stdClass $cm
1778 * @param stdClass $course
1779 * @param navigation_node $activity
1782 protected function load_activity($cm, stdClass
$course, navigation_node
$activity) {
1785 // make sure we have a $cm from get_fast_modinfo as this contains activity access details
1786 if (!($cm instanceof cm_info
)) {
1787 $modinfo = get_fast_modinfo($course);
1788 $cm = $modinfo->get_cm($cm->id
);
1791 $activity->make_active();
1792 $file = $CFG->dirroot
.'/mod/'.$cm->modname
.'/lib.php';
1793 $function = $cm->modname
.'_extend_navigation';
1795 if (file_exists($file)) {
1796 require_once($file);
1797 if (function_exists($function)) {
1798 $activtyrecord = $DB->get_record($cm->modname
, array('id' => $cm->instance
), '*', MUST_EXIST
);
1799 $function($activity, $course, $activtyrecord, $cm);
1803 $activity->nodetype
= navigation_node
::NODETYPE_LEAF
;
1807 * Loads user specific information into the navigation in the appopriate place.
1809 * If no user is provided the current user is assumed.
1811 * @param stdClass $user
1814 protected function load_for_user($user=null, $forceforcontext=false) {
1815 global $DB, $CFG, $USER;
1817 if ($user === null) {
1818 // We can't require login here but if the user isn't logged in we don't
1819 // want to show anything
1820 if (!isloggedin() ||
isguestuser()) {
1824 } else if (!is_object($user)) {
1825 // If the user is not an object then get them from the database
1826 list($select, $join) = context_instance_preload_sql('u.id', CONTEXT_USER
, 'ctx');
1827 $sql = "SELECT u.* $select FROM {user} u $join WHERE u.id = :userid";
1828 $user = $DB->get_record_sql($sql, array('userid' => (int)$user), MUST_EXIST
);
1829 context_instance_preload($user);
1832 $iscurrentuser = ($user->id
== $USER->id
);
1834 $usercontext = get_context_instance(CONTEXT_USER
, $user->id
);
1836 // Get the course set against the page, by default this will be the site
1837 $course = $this->page
->course
;
1838 $baseargs = array('id'=>$user->id
);
1839 if ($course->id
!= SITEID
&& (!$iscurrentuser ||
$forceforcontext)) {
1840 $coursenode = $this->load_course($course);
1841 $baseargs['course'] = $course->id
;
1842 $coursecontext = get_context_instance(CONTEXT_COURSE
, $course->id
);
1843 $issitecourse = false;
1845 // Load all categories and get the context for the system
1846 $coursecontext = get_context_instance(CONTEXT_SYSTEM
);
1847 $issitecourse = true;
1850 // Create a node to add user information under.
1851 if ($iscurrentuser && !$forceforcontext) {
1852 // If it's the current user the information will go under the profile root node
1853 $usernode = $this->rootnodes
['myprofile'];
1854 $course = get_site();
1855 $coursecontext = get_context_instance(CONTEXT_COURSE
, $course->id
);
1856 $issitecourse = true;
1858 if (!$issitecourse) {
1859 // Not the current user so add it to the participants node for the current course
1860 $usersnode = $coursenode->get('participants', navigation_node
::TYPE_CONTAINER
);
1861 $userviewurl = new moodle_url('/user/view.php', $baseargs);
1863 // This is the site so add a users node to the root branch
1864 $usersnode = $this->rootnodes
['users'];
1865 if (has_capability('moodle/course:viewparticipants', $coursecontext)) {
1866 $usersnode->action
= new moodle_url('/user/index.php', array('id'=>$course->id
));
1868 $userviewurl = new moodle_url('/user/profile.php', $baseargs);
1871 // We should NEVER get here, if the course hasn't been populated
1872 // with a participants node then the navigaiton either wasn't generated
1873 // for it (you are missing a require_login or set_context call) or
1874 // you don't have access.... in the interests of no leaking informatin
1875 // we simply quit...
1878 // Add a branch for the current user
1879 $usernode = $usersnode->add(fullname($user, true), $userviewurl, self
::TYPE_USER
, null, $user->id
);
1881 if ($this->page
->context
->contextlevel
== CONTEXT_USER
&& $user->id
== $this->page
->context
->instanceid
) {
1882 $usernode->make_active();
1886 // If the user is the current user or has permission to view the details of the requested
1887 // user than add a view profile link.
1888 if ($iscurrentuser ||
has_capability('moodle/user:viewdetails', $coursecontext) ||
has_capability('moodle/user:viewdetails', $usercontext)) {
1889 if ($issitecourse ||
($iscurrentuser && !$forceforcontext)) {
1890 $usernode->add(get_string('viewprofile'), new moodle_url('/user/profile.php',$baseargs));
1892 $usernode->add(get_string('viewprofile'), new moodle_url('/user/view.php',$baseargs));
1896 // Add nodes for forum posts and discussions if the user can view either or both
1897 // There are no capability checks here as the content of the page is based
1898 // purely on the forums the current user has access too.
1899 $forumtab = $usernode->add(get_string('forumposts', 'forum'));
1900 $forumtab->add(get_string('posts', 'forum'), new moodle_url('/mod/forum/user.php', $baseargs));
1901 $forumtab->add(get_string('discussions', 'forum'), new moodle_url('/mod/forum/user.php', array_merge($baseargs, array('mode'=>'discussions'))));
1904 if (!empty($CFG->bloglevel
)) {
1905 if (!$this->cache
->cached('userblogoptions'.$user->id
)) {
1906 require_once($CFG->dirroot
.'/blog/lib.php');
1907 // Get all options for the user
1908 $options = blog_get_options_for_user($user);
1909 $this->cache
->set('userblogoptions'.$user->id
, $options);
1911 $options = $this->cache
->{'userblogoptions'.$user->id
};
1914 if (count($options) > 0) {
1915 $blogs = $usernode->add(get_string('blogs', 'blog'), null, navigation_node
::TYPE_CONTAINER
);
1916 foreach ($options as $option) {
1917 $blogs->add($option['string'], $option['link']);
1922 if (!empty($CFG->messaging
)) {
1923 $messageargs = null;
1924 if ($USER->id
!=$user->id
) {
1925 $messageargs = array('id'=>$user->id
);
1927 $url = new moodle_url('/message/index.php',$messageargs);
1928 $usernode->add(get_string('messages', 'message'), $url, self
::TYPE_SETTING
, null, 'messages');
1931 $context = get_context_instance(CONTEXT_USER
, $USER->id
);
1932 if ($iscurrentuser && has_capability('moodle/user:manageownfiles', $context)) {
1933 $url = new moodle_url('/user/files.php');
1934 $usernode->add(get_string('myfiles'), $url, self
::TYPE_SETTING
);
1937 // Add a node to view the users notes if permitted
1938 if (!empty($CFG->enablenotes
) && has_any_capability(array('moodle/notes:manage', 'moodle/notes:view'), $coursecontext)) {
1939 $url = new moodle_url('/notes/index.php',array('user'=>$user->id
));
1940 if ($coursecontext->instanceid
) {
1941 $url->param('course', $coursecontext->instanceid
);
1943 $usernode->add(get_string('notes', 'notes'), $url);
1946 // Add a reports tab and then add reports the the user has permission to see.
1947 $anyreport = has_capability('moodle/user:viewuseractivitiesreport', $usercontext);
1949 $outlinetreport = ($anyreport ||
has_capability('coursereport/outline:view', $coursecontext));
1950 $logtodayreport = ($anyreport ||
has_capability('coursereport/log:viewtoday', $coursecontext));
1951 $logreport = ($anyreport ||
has_capability('coursereport/log:view', $coursecontext));
1952 $statsreport = ($anyreport ||
has_capability('coursereport/stats:view', $coursecontext));
1954 $somereport = $outlinetreport ||
$logtodayreport ||
$logreport ||
$statsreport;
1956 $viewreports = ($anyreport ||
$somereport ||
($course->showreports
&& $iscurrentuser && $forceforcontext));
1958 $reporttab = $usernode->add(get_string('activityreports'));
1959 $reportargs = array('user'=>$user->id
);
1960 if (!empty($course->id
)) {
1961 $reportargs['id'] = $course->id
;
1963 $reportargs['id'] = SITEID
;
1965 if ($viewreports ||
$outlinetreport) {
1966 $reporttab->add(get_string('outlinereport'), new moodle_url('/course/user.php', array_merge($reportargs, array('mode'=>'outline'))));
1967 $reporttab->add(get_string('completereport'), new moodle_url('/course/user.php', array_merge($reportargs, array('mode'=>'complete'))));
1970 if ($viewreports ||
$logtodayreport) {
1971 $reporttab->add(get_string('todaylogs'), new moodle_url('/course/user.php', array_merge($reportargs, array('mode'=>'todaylogs'))));
1974 if ($viewreports ||
$logreport ) {
1975 $reporttab->add(get_string('alllogs'), new moodle_url('/course/user.php', array_merge($reportargs, array('mode'=>'alllogs'))));
1978 if (!empty($CFG->enablestats
)) {
1979 if ($viewreports ||
$statsreport) {
1980 $reporttab->add(get_string('stats'), new moodle_url('/course/user.php', array_merge($reportargs, array('mode'=>'stats'))));
1984 $gradeaccess = false;
1985 if (has_capability('moodle/grade:viewall', $coursecontext)) {
1986 //ok - can view all course grades
1987 $gradeaccess = true;
1988 } else if ($course->showgrades
) {
1989 if ($iscurrentuser && has_capability('moodle/grade:view', $coursecontext)) {
1990 //ok - can view own grades
1991 $gradeaccess = true;
1992 } else if (has_capability('moodle/grade:viewall', $usercontext)) {
1993 // ok - can view grades of this user - parent most probably
1994 $gradeaccess = true;
1995 } else if ($anyreport) {
1996 // ok - can view grades of this user - parent most probably
1997 $gradeaccess = true;
2001 $reporttab->add(get_string('grade'), new moodle_url('/course/user.php', array_merge($reportargs, array('mode'=>'grade'))));
2004 // Check the number of nodes in the report node... if there are none remove
2006 $reporttab->trim_if_empty();
2009 // If the user is the current user add the repositories for the current user
2010 $hiddenfields = array_flip(explode(',', $CFG->hiddenuserfields
));
2011 if ($iscurrentuser) {
2012 if (!$this->cache
->cached('contexthasrepos'.$usercontext->id
)) {
2013 require_once($CFG->dirroot
. '/repository/lib.php');
2014 $editabletypes = repository
::get_editable_types($usercontext);
2015 $haseditabletypes = !empty($editabletypes);
2016 unset($editabletypes);
2017 $this->cache
->set('contexthasrepos'.$usercontext->id
, $haseditabletypes);
2019 $haseditabletypes = $this->cache
->{'contexthasrepos'.$usercontext->id
};
2021 if ($haseditabletypes) {
2022 $usernode->add(get_string('repositories', 'repository'), new moodle_url('/repository/manage_instances.php', array('contextid' => $usercontext->id
)));
2024 } else if ($course->id
== SITEID
&& has_capability('moodle/user:viewdetails', $usercontext) && (!in_array('mycourses', $hiddenfields) ||
has_capability('moodle/user:viewhiddendetails', $coursecontext))) {
2026 // Add view grade report is permitted
2027 $reports = get_plugin_list('gradereport');
2028 arsort($reports); // user is last, we want to test it first
2030 $userscourses = enrol_get_users_courses($user->id
);
2031 $userscoursesnode = $usernode->add(get_string('courses'));
2033 foreach ($userscourses as $usercourse) {
2034 $usercoursecontext = get_context_instance(CONTEXT_COURSE
, $usercourse->id
);
2035 $usercourseshortname = format_string($usercourse->shortname
, true, array('context' => $usercoursecontext));
2036 $usercoursenode = $userscoursesnode->add($usercourseshortname, new moodle_url('/user/view.php', array('id'=>$user->id
, 'course'=>$usercourse->id
)), self
::TYPE_CONTAINER
);
2038 $gradeavailable = has_capability('moodle/grade:viewall', $usercoursecontext);
2039 if (!$gradeavailable && !empty($usercourse->showgrades
) && is_array($reports) && !empty($reports)) {
2040 foreach ($reports as $plugin => $plugindir) {
2041 if (has_capability('gradereport/'.$plugin.':view', $usercoursecontext)) {
2042 //stop when the first visible plugin is found
2043 $gradeavailable = true;
2049 if ($gradeavailable) {
2050 $url = new moodle_url('/grade/report/index.php', array('id'=>$usercourse->id
));
2051 $usercoursenode->add(get_string('grades'), $url, self
::TYPE_SETTING
, null, null, new pix_icon('i/grades', ''));
2054 // Add a node to view the users notes if permitted
2055 if (!empty($CFG->enablenotes
) && has_any_capability(array('moodle/notes:manage', 'moodle/notes:view'), $usercoursecontext)) {
2056 $url = new moodle_url('/notes/index.php',array('user'=>$user->id
, 'course'=>$usercourse->id
));
2057 $usercoursenode->add(get_string('notes', 'notes'), $url, self
::TYPE_SETTING
);
2060 if (can_access_course(get_context_instance(CONTEXT_COURSE
, $usercourse->id
), $user->id
)) {
2061 $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', ''));
2064 $outlinetreport = ($anyreport ||
has_capability('coursereport/outline:view', $usercoursecontext));
2065 $logtodayreport = ($anyreport ||
has_capability('coursereport/log:viewtoday', $usercoursecontext));
2066 $logreport = ($anyreport ||
has_capability('coursereport/log:view', $usercoursecontext));
2067 $statsreport = ($anyreport ||
has_capability('coursereport/stats:view', $usercoursecontext));
2068 if ($outlinetreport ||
$logtodayreport ||
$logreport ||
$statsreport) {
2069 $reporttab = $usercoursenode->add(get_string('activityreports'));
2070 $reportargs = array('user'=>$user->id
, 'id'=>$usercourse->id
);
2071 if ($outlinetreport) {
2072 $reporttab->add(get_string('outlinereport'), new moodle_url('/course/user.php', array_merge($reportargs, array('mode'=>'outline'))));
2073 $reporttab->add(get_string('completereport'), new moodle_url('/course/user.php', array_merge($reportargs, array('mode'=>'complete'))));
2076 if ($logtodayreport) {
2077 $reporttab->add(get_string('todaylogs'), new moodle_url('/course/user.php', array_merge($reportargs, array('mode'=>'todaylogs'))));
2081 $reporttab->add(get_string('alllogs'), new moodle_url('/course/user.php', array_merge($reportargs, array('mode'=>'alllogs'))));
2084 if (!empty($CFG->enablestats
) && $statsreport) {
2085 $reporttab->add(get_string('stats'), new moodle_url('/course/user.php', array_merge($reportargs, array('mode'=>'stats'))));
2094 * This method simply checks to see if a given module can extend the navigation.
2096 * TODO: A shared caching solution should be used to save details on what extends navigation
2098 * @param string $modname
2101 protected static function module_extends_navigation($modname) {
2103 static $extendingmodules = array();
2104 if (!array_key_exists($modname, $extendingmodules)) {
2105 $extendingmodules[$modname] = false;
2106 $file = $CFG->dirroot
.'/mod/'.$modname.'/lib.php';
2107 if (file_exists($file)) {
2108 $function = $modname.'_extend_navigation';
2109 require_once($file);
2110 $extendingmodules[$modname] = (function_exists($function));
2113 return $extendingmodules[$modname];
2116 * Extends the navigation for the given user.
2118 * @param stdClass $user A user from the database
2120 public function extend_for_user($user) {
2121 $this->extendforuser
[] = $user;
2125 * Returns all of the users the navigation is being extended for
2129 public function get_extending_users() {
2130 return $this->extendforuser
;
2133 * Adds the given course to the navigation structure.
2135 * @param stdClass $course
2136 * @return navigation_node
2138 public function add_course(stdClass
$course, $forcegeneric = false, $ismycourse = false) {
2141 // We found the course... we can return it now :)
2142 if (!$forcegeneric && array_key_exists($course->id
, $this->addedcourses
)) {
2143 return $this->addedcourses
[$course->id
];
2146 $coursecontext = get_context_instance(CONTEXT_COURSE
, $course->id
);
2148 if ($course->id
!= SITEID
&& !$course->visible
) {
2149 if (is_role_switched($course->id
)) {
2150 // user has to be able to access course in order to switch, let's skip the visibility test here
2151 } else if (!has_capability('moodle/course:viewhiddencourses', $coursecontext)) {
2156 $issite = ($course->id
== SITEID
);
2157 $ismycourse = ($ismycourse && !$forcegeneric);
2158 $shortname = format_string($course->shortname
, true, array('context' => $coursecontext));
2163 if (empty($CFG->usesitenameforsitepages
)) {
2164 $shortname = get_string('sitepages');
2166 } else if ($ismycourse) {
2167 $parent = $this->rootnodes
['mycourses'];
2168 $url = new moodle_url('/course/view.php', array('id'=>$course->id
));
2170 $parent = $this->rootnodes
['courses'];
2171 $url = new moodle_url('/course/view.php', array('id'=>$course->id
));
2174 if (!$ismycourse && !$issite && !empty($course->category
)) {
2175 if ($this->show_categories()) {
2176 // We need to load the category structure for this course
2177 $this->load_all_categories($course->category
);
2179 if (array_key_exists($course->category
, $this->addedcategories
)) {
2180 $parent = $this->addedcategories
[$course->category
];
2181 // This could lead to the course being created so we should check whether it is the case again
2182 if (!$forcegeneric && array_key_exists($course->id
, $this->addedcourses
)) {
2183 return $this->addedcourses
[$course->id
];
2188 $coursenode = $parent->add($shortname, $url, self
::TYPE_COURSE
, $shortname, $course->id
);
2189 $coursenode->nodetype
= self
::NODETYPE_BRANCH
;
2190 $coursenode->hidden
= (!$course->visible
);
2191 $coursenode->title(format_string($course->fullname
, true, array('context' => get_context_instance(CONTEXT_COURSE
, $course->id
))));
2192 if (!$forcegeneric) {
2193 $this->addedcourses
[$course->id
] = &$coursenode;
2195 if ($ismycourse && !empty($CFG->navshowallcourses
)) {
2196 // We need to add this course to the general courses node as well as the
2197 // my courses node, rerun the function with the kill param
2198 $genericcourse = $this->add_course($course, true);
2199 if ($genericcourse->isactive
) {
2200 $genericcourse->make_inactive();
2201 $genericcourse->collapse
= true;
2202 if ($genericcourse->parent
&& $genericcourse->parent
->type
== self
::TYPE_CATEGORY
) {
2203 $parent = $genericcourse->parent
;
2204 while ($parent && $parent->type
== self
::TYPE_CATEGORY
) {
2205 $parent->collapse
= true;
2206 $parent = $parent->parent
;
2215 * Adds essential course nodes to the navigation for the given course.
2217 * This method adds nodes such as reports, blogs and participants
2219 * @param navigation_node $coursenode
2220 * @param stdClass $course
2223 public function add_course_essentials($coursenode, stdClass
$course) {
2226 if ($course->id
== SITEID
) {
2227 return $this->add_front_page_course_essentials($coursenode, $course);
2230 if ($coursenode == false ||
!($coursenode instanceof navigation_node
) ||
$coursenode->get('participants', navigation_node
::TYPE_CONTAINER
)) {
2235 if (has_capability('moodle/course:viewparticipants', $this->page
->context
)) {
2236 $participants = $coursenode->add(get_string('participants'), new moodle_url('/user/index.php?id='.$course->id
), self
::TYPE_CONTAINER
, get_string('participants'), 'participants');
2237 $currentgroup = groups_get_course_group($course, true);
2238 if ($course->id
== SITEID
) {
2240 } else if ($course->id
&& !$currentgroup) {
2241 $filterselect = $course->id
;
2243 $filterselect = $currentgroup;
2245 $filterselect = clean_param($filterselect, PARAM_INT
);
2246 if (($CFG->bloglevel
== BLOG_GLOBAL_LEVEL
or ($CFG->bloglevel
== BLOG_SITE_LEVEL
and (isloggedin() and !isguestuser())))
2247 and has_capability('moodle/blog:view', get_context_instance(CONTEXT_SYSTEM
))) {
2248 $blogsurls = new moodle_url('/blog/index.php', array('courseid' => $filterselect));
2249 $participants->add(get_string('blogs','blog'), $blogsurls->out());
2251 if (!empty($CFG->enablenotes
) && (has_capability('moodle/notes:manage', $this->page
->context
) ||
has_capability('moodle/notes:view', $this->page
->context
))) {
2252 $participants->add(get_string('notes','notes'), new moodle_url('/notes/index.php', array('filtertype'=>'course', 'filterselect'=>$filterselect)));
2254 } else if (count($this->extendforuser
) > 0 ||
$this->page
->course
->id
== $course->id
) {
2255 $participants = $coursenode->add(get_string('participants'), null, self
::TYPE_CONTAINER
, get_string('participants'), 'participants');
2258 // View course reports
2259 if (has_capability('moodle/site:viewreports', $this->page
->context
)) { // basic capability for listing of reports
2260 $reportnav = $coursenode->add(get_string('reports'), new moodle_url('/course/report.php', array('id'=>$course->id
)), self
::TYPE_CONTAINER
, null, null, new pix_icon('i/stats', ''));
2261 $coursereports = get_plugin_list('coursereport');
2262 foreach ($coursereports as $report=>$dir) {
2263 $libfile = $CFG->dirroot
.'/course/report/'.$report.'/lib.php';
2264 if (file_exists($libfile)) {
2265 require_once($libfile);
2266 $reportfunction = $report.'_report_extend_navigation';
2267 if (function_exists($report.'_report_extend_navigation')) {
2268 $reportfunction($reportnav, $course, $this->page
->context
);
2276 * This generates the the structure of the course that won't be generated when
2277 * the modules and sections are added.
2279 * Things such as the reports branch, the participants branch, blogs... get
2280 * added to the course node by this method.
2282 * @param navigation_node $coursenode
2283 * @param stdClass $course
2284 * @return bool True for successfull generation
2286 public function add_front_page_course_essentials(navigation_node
$coursenode, stdClass
$course) {
2289 if ($coursenode == false ||
$coursenode->get('frontpageloaded', navigation_node
::TYPE_CUSTOM
)) {
2293 // Hidden node that we use to determine if the front page navigation is loaded.
2294 // This required as there are not other guaranteed nodes that may be loaded.
2295 $coursenode->add('frontpageloaded', null, self
::TYPE_CUSTOM
, null, 'frontpageloaded')->display
= false;
2298 if (has_capability('moodle/course:viewparticipants', get_system_context())) {
2299 $coursenode->add(get_string('participants'), new moodle_url('/user/index.php?id='.$course->id
), self
::TYPE_CUSTOM
, get_string('participants'), 'participants');
2305 if (!empty($CFG->bloglevel
)
2306 and ($CFG->bloglevel
== BLOG_GLOBAL_LEVEL
or ($CFG->bloglevel
== BLOG_SITE_LEVEL
and (isloggedin() and !isguestuser())))
2307 and has_capability('moodle/blog:view', get_context_instance(CONTEXT_SYSTEM
))) {
2308 $blogsurls = new moodle_url('/blog/index.php', array('courseid' => $filterselect));
2309 $coursenode->add(get_string('blogs','blog'), $blogsurls->out());
2313 if (!empty($CFG->enablenotes
) && (has_capability('moodle/notes:manage', $this->page
->context
) ||
has_capability('moodle/notes:view', $this->page
->context
))) {
2314 $coursenode->add(get_string('notes','notes'), new moodle_url('/notes/index.php', array('filtertype'=>'course', 'filterselect'=>$filterselect)));
2318 if (!empty($CFG->usetags
) && isloggedin()) {
2319 $coursenode->add(get_string('tags', 'tag'), new moodle_url('/tag/search.php'));
2323 $calendarurl = new moodle_url('/calendar/view.php', array('view' => 'month'));
2324 $coursenode->add(get_string('calendar', 'calendar'), $calendarurl, self
::TYPE_CUSTOM
, null, 'calendar');
2326 // View course reports
2327 if (has_capability('moodle/site:viewreports', $this->page
->context
)) { // basic capability for listing of reports
2328 $reportnav = $coursenode->add(get_string('reports'), new moodle_url('/course/report.php', array('id'=>$course->id
)), self
::TYPE_CONTAINER
, null, null, new pix_icon('i/stats', ''));
2329 $coursereports = get_plugin_list('coursereport');
2330 foreach ($coursereports as $report=>$dir) {
2331 $libfile = $CFG->dirroot
.'/course/report/'.$report.'/lib.php';
2332 if (file_exists($libfile)) {
2333 require_once($libfile);
2334 $reportfunction = $report.'_report_extend_navigation';
2335 if (function_exists($report.'_report_extend_navigation')) {
2336 $reportfunction($reportnav, $course, $this->page
->context
);
2345 * Clears the navigation cache
2347 public function clear_cache() {
2348 $this->cache
->clear();
2352 * Sets an expansion limit for the navigation
2354 * The expansion limit is used to prevent the display of content that has a type
2355 * greater than the provided $type.
2357 * Can be used to ensure things such as activities or activity content don't get
2358 * shown on the navigation.
2359 * They are still generated in order to ensure the navbar still makes sense.
2361 * @param int $type One of navigation_node::TYPE_*
2364 public function set_expansion_limit($type) {
2365 $nodes = $this->find_all_of_type($type);
2366 foreach ($nodes as &$node) {
2367 // We need to generate the full site node
2368 if ($type == self
::TYPE_COURSE
&& $node->key
== SITEID
) {
2371 foreach ($node->children
as &$child) {
2372 // We still want to show course reports and participants containers
2373 // or there will be navigation missing.
2374 if ($type == self
::TYPE_COURSE
&& $child->type
=== self
::TYPE_CONTAINER
) {
2377 $child->display
= false;
2383 * Attempts to get the navigation with the given key from this nodes children.
2385 * This function only looks at this nodes children, it does NOT look recursivily.
2386 * If the node can't be found then false is returned.
2388 * If you need to search recursivily then use the {@see find()} method.
2390 * Note: If you are trying to set the active node {@see navigation_node::override_active_url()}
2391 * may be of more use to you.
2393 * @param string|int $key The key of the node you wish to receive.
2394 * @param int $type One of navigation_node::TYPE_*
2395 * @return navigation_node|false
2397 public function get($key, $type = null) {
2398 if (!$this->initialised
) {
2399 $this->initialise();
2401 return parent
::get($key, $type);
2405 * Searches this nodes children and thier children to find a navigation node
2406 * with the matching key and type.
2408 * This method is recursive and searches children so until either a node is
2409 * found of there are no more nodes to search.
2411 * If you know that the node being searched for is a child of this node
2412 * then use the {@see get()} method instead.
2414 * Note: If you are trying to set the active node {@see navigation_node::override_active_url()}
2415 * may be of more use to you.
2417 * @param string|int $key The key of the node you wish to receive.
2418 * @param int $type One of navigation_node::TYPE_*
2419 * @return navigation_node|false
2421 public function find($key, $type) {
2422 if (!$this->initialised
) {
2423 $this->initialise();
2425 return parent
::find($key, $type);
2430 * The limited global navigation class used for the AJAX extension of the global
2433 * The primary methods that are used in the global navigation class have been overriden
2434 * to ensure that only the relevant branch is generated at the root of the tree.
2435 * This can be done because AJAX is only used when the backwards structure for the
2436 * requested branch exists.
2437 * This has been done only because it shortens the amounts of information that is generated
2438 * which of course will speed up the response time.. because no one likes laggy AJAX.
2440 * @package moodlecore
2441 * @subpackage navigation
2442 * @copyright 2009 Sam Hemelryk
2443 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
2445 class global_navigation_for_ajax
extends global_navigation
{
2447 protected $branchtype;
2448 protected $instanceid;
2451 protected $expandable = array();
2454 * Constructs the navigation for use in AJAX request
2456 public function __construct($page, $branchtype, $id) {
2457 $this->page
= $page;
2458 $this->cache
= new navigation_cache(NAVIGATION_CACHE_NAME
);
2459 $this->children
= new navigation_node_collection();
2460 $this->branchtype
= $branchtype;
2461 $this->instanceid
= $id;
2462 $this->initialise();
2465 * Initialise the navigation given the type and id for the branch to expand.
2467 * @return array The expandable nodes
2469 public function initialise() {
2470 global $CFG, $DB, $SITE;
2472 if ($this->initialised ||
during_initial_install()) {
2473 return $this->expandable
;
2475 $this->initialised
= true;
2477 $this->rootnodes
= array();
2478 $this->rootnodes
['site'] = $this->add_course($SITE);
2479 $this->rootnodes
['courses'] = $this->add(get_string('courses'), null, self
::TYPE_ROOTNODE
, null, 'courses');
2481 // Branchtype will be one of navigation_node::TYPE_*
2482 switch ($this->branchtype
) {
2483 case self
::TYPE_CATEGORY
:
2484 $this->load_all_categories($this->instanceid
);
2486 if (!empty($CFG->navcourselimit
)) {
2487 $limit = (int)$CFG->navcourselimit
;
2489 $courses = $DB->get_records('course', array('category' => $this->instanceid
), 'sortorder','*', 0, $limit);
2490 foreach ($courses as $course) {
2491 $this->add_course($course);
2494 case self
::TYPE_COURSE
:
2495 $course = $DB->get_record('course', array('id' => $this->instanceid
), '*', MUST_EXIST
);
2496 require_course_login($course);
2497 $this->page
->set_context(get_context_instance(CONTEXT_COURSE
, $course->id
));
2498 $coursenode = $this->add_course($course);
2499 $this->add_course_essentials($coursenode, $course);
2500 if ($this->format_display_course_content($course->format
)) {
2501 $this->load_course_sections($course, $coursenode);
2504 case self
::TYPE_SECTION
:
2505 $sql = 'SELECT c.*, cs.section AS sectionnumber
2507 LEFT JOIN {course_sections} cs ON cs.course = c.id
2509 $course = $DB->get_record_sql($sql, array($this->instanceid
), MUST_EXIST
);
2510 require_course_login($course);
2511 $this->page
->set_context(get_context_instance(CONTEXT_COURSE
, $course->id
));
2512 $coursenode = $this->add_course($course);
2513 $this->add_course_essentials($coursenode, $course);
2514 $sections = $this->load_course_sections($course, $coursenode);
2515 list($sectionarray, $activities) = $this->generate_sections_and_activities($course);
2516 $this->load_section_activities($sections[$course->sectionnumber
]->sectionnode
, $course->sectionnumber
, $activities);
2518 case self
::TYPE_ACTIVITY
:
2521 JOIN {course_modules} cm ON cm.course = c.id
2522 WHERE cm.id = :cmid";
2523 $params = array('cmid' => $this->instanceid
);
2524 $course = $DB->get_record_sql($sql, $params, MUST_EXIST
);
2525 $modinfo = get_fast_modinfo($course);
2526 $cm = $modinfo->get_cm($this->instanceid
);
2527 require_course_login($course, true, $cm);
2528 $this->page
->set_context(get_context_instance(CONTEXT_MODULE
, $cm->id
));
2529 $coursenode = $this->load_course($course);
2530 if ($course->id
== SITEID
) {
2531 $modulenode = $this->load_activity($cm, $course, $coursenode->find($cm->id
, self
::TYPE_ACTIVITY
));
2533 $sections = $this->load_course_sections($course, $coursenode);
2534 list($sectionarray, $activities) = $this->generate_sections_and_activities($course);
2535 $activities = $this->load_section_activities($sections[$cm->sectionnum
]->sectionnode
, $cm->sectionnum
, $activities);
2536 $modulenode = $this->load_activity($cm, $course, $activities[$cm->id
]);
2540 throw new Exception('Unknown type');
2541 return $this->expandable
;
2544 if ($this->page
->context
->contextlevel
== CONTEXT_COURSE
&& $this->page
->context
->instanceid
!= SITEID
) {
2545 $this->load_for_user(null, true);
2548 $this->find_expandable($this->expandable
);
2549 return $this->expandable
;
2553 * Returns an array of expandable nodes
2556 public function get_expandable() {
2557 return $this->expandable
;
2564 * This class is used to manage the navbar, which is initialised from the navigation
2565 * object held by PAGE
2567 * @package moodlecore
2568 * @subpackage navigation
2569 * @copyright 2009 Sam Hemelryk
2570 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
2572 class navbar
extends navigation_node
{
2574 protected $initialised = false;
2576 protected $keys = array();
2577 /** @var null|string */
2578 protected $content = null;
2579 /** @var moodle_page object */
2582 protected $ignoreactive = false;
2584 protected $duringinstall = false;
2586 protected $hasitems = false;
2590 public $children = array();
2592 public $includesettingsbase = false;
2594 * The almighty constructor
2596 * @param moodle_page $page
2598 public function __construct(moodle_page
$page) {
2600 if (during_initial_install()) {
2601 $this->duringinstall
= true;
2604 $this->page
= $page;
2605 $this->text
= get_string('home');
2606 $this->shorttext
= get_string('home');
2607 $this->action
= new moodle_url($CFG->wwwroot
);
2608 $this->nodetype
= self
::NODETYPE_BRANCH
;
2609 $this->type
= self
::TYPE_SYSTEM
;
2613 * Quick check to see if the navbar will have items in.
2615 * @return bool Returns true if the navbar will have items, false otherwise
2617 public function has_items() {
2618 if ($this->duringinstall
) {
2620 } else if ($this->hasitems
!== false) {
2623 $this->page
->navigation
->initialise($this->page
);
2625 $activenodefound = ($this->page
->navigation
->contains_active_node() ||
2626 $this->page
->settingsnav
->contains_active_node());
2628 $outcome = (count($this->children
)>0 ||
(!$this->ignoreactive
&& $activenodefound));
2629 $this->hasitems
= $outcome;
2634 * Turn on/off ignore active
2636 * @param bool $setting
2638 public function ignore_active($setting=true) {
2639 $this->ignoreactive
= ($setting);
2641 public function get($key, $type = null) {
2642 foreach ($this->children
as &$child) {
2643 if ($child->key
=== $key && ($type == null ||
$type == $child->type
)) {
2650 * Returns an array of navigation_node's that make up the navbar.
2654 public function get_items() {
2656 // Make sure that navigation is initialised
2657 if (!$this->has_items()) {
2660 if ($this->items
!== null) {
2661 return $this->items
;
2664 if (count($this->children
) > 0) {
2665 // Add the custom children
2666 $items = array_reverse($this->children
);
2669 $navigationactivenode = $this->page
->navigation
->find_active_node();
2670 $settingsactivenode = $this->page
->settingsnav
->find_active_node();
2672 // Check if navigation contains the active node
2673 if (!$this->ignoreactive
) {
2675 if ($navigationactivenode && $settingsactivenode) {
2676 // Parse a combined navigation tree
2677 while ($settingsactivenode && $settingsactivenode->parent
!== null) {
2678 if (!$settingsactivenode->mainnavonly
) {
2679 $items[] = $settingsactivenode;
2681 $settingsactivenode = $settingsactivenode->parent
;
2683 if (!$this->includesettingsbase
) {
2684 // Removes the first node from the settings (root node) from the list
2687 while ($navigationactivenode && $navigationactivenode->parent
!== null) {
2688 if (!$navigationactivenode->mainnavonly
) {
2689 $items[] = $navigationactivenode;
2691 $navigationactivenode = $navigationactivenode->parent
;
2693 } else if ($navigationactivenode) {
2694 // Parse the navigation tree to get the active node
2695 while ($navigationactivenode && $navigationactivenode->parent
!== null) {
2696 if (!$navigationactivenode->mainnavonly
) {
2697 $items[] = $navigationactivenode;
2699 $navigationactivenode = $navigationactivenode->parent
;
2701 } else if ($settingsactivenode) {
2702 // Parse the settings navigation to get the active node
2703 while ($settingsactivenode && $settingsactivenode->parent
!== null) {
2704 if (!$settingsactivenode->mainnavonly
) {
2705 $items[] = $settingsactivenode;
2707 $settingsactivenode = $settingsactivenode->parent
;
2712 $items[] = new navigation_node(array(
2713 'text'=>$this->page
->navigation
->text
,
2714 'shorttext'=>$this->page
->navigation
->shorttext
,
2715 'key'=>$this->page
->navigation
->key
,
2716 'action'=>$this->page
->navigation
->action
2719 $this->items
= array_reverse($items);
2720 return $this->items
;
2724 * Add a new navigation_node to the navbar, overrides parent::add
2726 * This function overrides {@link navigation_node::add()} so that we can change
2727 * the way nodes get added to allow us to simply call add and have the node added to the
2730 * @param string $text
2731 * @param string|moodle_url $action
2733 * @param string|int $key
2734 * @param string $shorttext
2735 * @param string $icon
2736 * @return navigation_node
2738 public function add($text, $action=null, $type=self
::TYPE_CUSTOM
, $shorttext=null, $key=null, pix_icon
$icon=null) {
2739 if ($this->content
!== null) {
2740 debugging('Nav bar items must be printed before $OUTPUT->header() has been called', DEBUG_DEVELOPER
);
2743 // Properties array used when creating the new navigation node
2748 // Set the action if one was provided
2749 if ($action!==null) {
2750 $itemarray['action'] = $action;
2752 // Set the shorttext if one was provided
2753 if ($shorttext!==null) {
2754 $itemarray['shorttext'] = $shorttext;
2756 // Set the icon if one was provided
2758 $itemarray['icon'] = $icon;
2760 // Default the key to the number of children if not provided
2761 if ($key === null) {
2762 $key = count($this->children
);
2765 $itemarray['key'] = $key;
2766 // Set the parent to this node
2767 $itemarray['parent'] = $this;
2768 // Add the child using the navigation_node_collections add method
2769 $this->children
[] = new navigation_node($itemarray);
2775 * Class used to manage the settings option for the current page
2777 * This class is used to manage the settings options in a tree format (recursively)
2778 * and was created initially for use with the settings blocks.
2780 * @package moodlecore
2781 * @subpackage navigation
2782 * @copyright 2009 Sam Hemelryk
2783 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
2785 class settings_navigation
extends navigation_node
{
2786 /** @var stdClass */
2788 /** @var moodle_page */
2791 protected $adminsection;
2793 protected $initialised = false;
2795 protected $userstoextendfor = array();
2796 /** @var navigation_cache **/
2800 * Sets up the object with basic settings and preparse it for use
2802 * @param moodle_page $page
2804 public function __construct(moodle_page
&$page) {
2805 if (during_initial_install()) {
2808 $this->page
= $page;
2809 // Initialise the main navigation. It is most important that this is done
2810 // before we try anything
2811 $this->page
->navigation
->initialise();
2812 // Initialise the navigation cache
2813 $this->cache
= new navigation_cache(NAVIGATION_CACHE_NAME
);
2814 $this->children
= new navigation_node_collection();
2817 * Initialise the settings navigation based on the current context
2819 * This function initialises the settings navigation tree for a given context
2820 * by calling supporting functions to generate major parts of the tree.
2823 public function initialise() {
2824 global $DB, $SESSION;
2826 if (during_initial_install()) {
2828 } else if ($this->initialised
) {
2831 $this->id
= 'settingsnav';
2832 $this->context
= $this->page
->context
;
2834 $context = $this->context
;
2835 if ($context->contextlevel
== CONTEXT_BLOCK
) {
2836 $this->load_block_settings();
2837 $context = $DB->get_record_sql('SELECT ctx.* FROM {block_instances} bi LEFT JOIN {context} ctx ON ctx.id=bi.parentcontextid WHERE bi.id=?', array($context->instanceid
));
2840 switch ($context->contextlevel
) {
2841 case CONTEXT_SYSTEM
:
2842 if ($this->page
->url
->compare(new moodle_url('/admin/settings.php', array('section'=>'frontpagesettings')))) {
2843 $this->load_front_page_settings(($context->id
== $this->context
->id
));
2846 case CONTEXT_COURSECAT
:
2847 $this->load_category_settings();
2849 case CONTEXT_COURSE
:
2850 if ($this->page
->course
->id
!= SITEID
) {
2851 $this->load_course_settings(($context->id
== $this->context
->id
));
2853 $this->load_front_page_settings(($context->id
== $this->context
->id
));
2856 case CONTEXT_MODULE
:
2857 $this->load_module_settings();
2858 $this->load_course_settings();
2861 if ($this->page
->course
->id
!= SITEID
) {
2862 $this->load_course_settings();
2867 $settings = $this->load_user_settings($this->page
->course
->id
);
2869 if (isloggedin() && !isguestuser() && (!property_exists($SESSION, 'load_navigation_admin') ||
$SESSION->load_navigation_admin
)) {
2870 $admin = $this->load_administration_settings();
2871 $SESSION->load_navigation_admin
= ($admin->has_children());
2876 if ($context->contextlevel
== CONTEXT_SYSTEM
&& $admin) {
2877 $admin->force_open();
2878 } else if ($context->contextlevel
== CONTEXT_USER
&& $settings) {
2879 $settings->force_open();
2882 // Check if the user is currently logged in as another user
2883 if (session_is_loggedinas()) {
2884 // Get the actual user, we need this so we can display an informative return link
2885 $realuser = session_get_realuser();
2886 // Add the informative return to original user link
2887 $url = new moodle_url('/course/loginas.php',array('id'=>$this->page
->course
->id
, 'return'=>1,'sesskey'=>sesskey()));
2888 $this->add(get_string('returntooriginaluser', 'moodle', fullname($realuser, true)), $url, self
::TYPE_SETTING
, null, null, new pix_icon('t/left', ''));
2891 foreach ($this->children
as $key=>$node) {
2892 if ($node->nodetype
!= self
::NODETYPE_BRANCH ||
$node->children
->count()===0) {
2896 $this->initialised
= true;
2899 * Override the parent function so that we can add preceeding hr's and set a
2900 * root node class against all first level element
2902 * It does this by first calling the parent's add method {@link navigation_node::add()}
2903 * and then proceeds to use the key to set class and hr
2905 * @param string $text
2906 * @param sting|moodle_url $url
2907 * @param string $shorttext
2908 * @param string|int $key
2910 * @param string $icon
2911 * @return navigation_node
2913 public function add($text, $url=null, $type=null, $shorttext=null, $key=null, pix_icon
$icon=null) {
2914 $node = parent
::add($text, $url, $type, $shorttext, $key, $icon);
2915 $node->add_class('root_node');
2920 * This function allows the user to add something to the start of the settings
2921 * navigation, which means it will be at the top of the settings navigation block
2923 * @param string $text
2924 * @param sting|moodle_url $url
2925 * @param string $shorttext
2926 * @param string|int $key
2928 * @param string $icon
2929 * @return navigation_node
2931 public function prepend($text, $url=null, $type=null, $shorttext=null, $key=null, pix_icon
$icon=null) {
2932 $children = $this->children
;
2933 $childrenclass = get_class($children);
2934 $this->children
= new $childrenclass;
2935 $node = $this->add($text, $url, $type, $shorttext, $key, $icon);
2936 foreach ($children as $child) {
2937 $this->children
->add($child);
2942 * Load the site administration tree
2944 * This function loads the site administration tree by using the lib/adminlib library functions
2946 * @param navigation_node $referencebranch A reference to a branch in the settings
2948 * @param part_of_admin_tree $adminbranch The branch to add, if null generate the admin
2949 * tree and start at the beginning
2950 * @return mixed A key to access the admin tree by
2952 protected function load_administration_settings(navigation_node
$referencebranch=null, part_of_admin_tree
$adminbranch=null) {
2955 // Check if we are just starting to generate this navigation.
2956 if ($referencebranch === null) {
2958 // Require the admin lib then get an admin structure
2959 if (!function_exists('admin_get_root')) {
2960 require_once($CFG->dirroot
.'/lib/adminlib.php');
2962 $adminroot = admin_get_root(false, false);
2963 // This is the active section identifier
2964 $this->adminsection
= $this->page
->url
->param('section');
2966 // Disable the navigation from automatically finding the active node
2967 navigation_node
::$autofindactive = false;
2968 $referencebranch = $this->add(get_string('administrationsite'), null, self
::TYPE_SETTING
, null, 'root');
2969 foreach ($adminroot->children
as $adminbranch) {
2970 $this->load_administration_settings($referencebranch, $adminbranch);
2972 navigation_node
::$autofindactive = true;
2974 // Use the admin structure to locate the active page
2975 if (!$this->contains_active_node() && $current = $adminroot->locate($this->adminsection
, true)) {
2976 $currentnode = $this;
2977 while (($pathkey = array_pop($current->path
))!==null && $currentnode) {
2978 $currentnode = $currentnode->get($pathkey);
2981 $currentnode->make_active();
2984 $this->scan_for_active_node($referencebranch);
2986 return $referencebranch;
2987 } else if ($adminbranch->check_access()) {
2988 // We have a reference branch that we can access and is not hidden `hurrah`
2989 // Now we need to display it and any children it may have
2992 if ($adminbranch instanceof admin_settingpage
) {
2993 $url = new moodle_url('/admin/settings.php', array('section'=>$adminbranch->name
));
2994 } else if ($adminbranch instanceof admin_externalpage
) {
2995 $url = $adminbranch->url
;
2999 $reference = $referencebranch->add($adminbranch->visiblename
, $url, self
::TYPE_SETTING
, null, $adminbranch->name
, $icon);
3001 if ($adminbranch->is_hidden()) {
3002 if (($adminbranch instanceof admin_externalpage ||
$adminbranch instanceof admin_settingpage
) && $adminbranch->name
== $this->adminsection
) {
3003 $reference->add_class('hidden');
3005 $reference->display
= false;
3009 // Check if we are generating the admin notifications and whether notificiations exist
3010 if ($adminbranch->name
=== 'adminnotifications' && admin_critical_warnings_present()) {
3011 $reference->add_class('criticalnotification');
3013 // Check if this branch has children
3014 if ($reference && isset($adminbranch->children
) && is_array($adminbranch->children
) && count($adminbranch->children
)>0) {
3015 foreach ($adminbranch->children
as $branch) {
3016 // Generate the child branches as well now using this branch as the reference
3017 $this->load_administration_settings($reference, $branch);
3020 $reference->icon
= new pix_icon('i/settings', '');
3026 * This function recursivily scans nodes until it finds the active node or there
3027 * are no more nodes.
3028 * @param navigation_node $node
3030 protected function scan_for_active_node(navigation_node
$node) {
3031 if (!$node->check_if_active() && $node->children
->count()>0) {
3032 foreach ($node->children
as &$child) {
3033 $this->scan_for_active_node($child);
3039 * Gets a navigation node given an array of keys that represent the path to
3042 * @param array $path
3043 * @return navigation_node|false
3045 protected function get_by_path(array $path) {
3046 $node = $this->get(array_shift($path));
3047 foreach ($path as $key) {
3054 * Generate the list of modules for the given course.
3056 * @param stdClass $course The course to get modules for
3058 protected function get_course_modules($course) {
3060 $mods = $modnames = $modnamesplural = $modnamesused = array();
3061 // This function is included when we include course/lib.php at the top
3063 get_all_mods($course->id
, $mods, $modnames, $modnamesplural, $modnamesused);
3064 $resources = array();
3065 $activities = array();
3066 foreach($modnames as $modname=>$modnamestr) {
3067 if (!course_allowed_module($course, $modname)) {
3071 $libfile = "$CFG->dirroot/mod/$modname/lib.php";
3072 if (!file_exists($libfile)) {
3075 include_once($libfile);
3076 $gettypesfunc = $modname.'_get_types';
3077 if (function_exists($gettypesfunc)) {
3078 $types = $gettypesfunc();
3079 foreach($types as $type) {
3080 if (!isset($type->modclass
) ||
!isset($type->typestr
)) {
3081 debugging('Incorrect activity type in '.$modname);
3084 if ($type->modclass
== MOD_CLASS_RESOURCE
) {
3085 $resources[html_entity_decode($type->type
)] = $type->typestr
;
3087 $activities[html_entity_decode($type->type
)] = $type->typestr
;
3091 $archetype = plugin_supports('mod', $modname, FEATURE_MOD_ARCHETYPE
, MOD_ARCHETYPE_OTHER
);
3092 if ($archetype == MOD_ARCHETYPE_RESOURCE
) {
3093 $resources[$modname] = $modnamestr;
3095 // all other archetypes are considered activity
3096 $activities[$modname] = $modnamestr;
3100 return array($resources, $activities);
3104 * This function loads the course settings that are available for the user
3106 * @param bool $forceopen If set to true the course node will be forced open
3107 * @return navigation_node|false
3109 protected function load_course_settings($forceopen = false) {
3112 $course = $this->page
->course
;
3113 $coursecontext = get_context_instance(CONTEXT_COURSE
, $course->id
);
3115 // note: do not test if enrolled or viewing here because we need the enrol link in Course administration section
3117 $coursenode = $this->add(get_string('courseadministration'), null, self
::TYPE_COURSE
, null, 'courseadmin');
3119 $coursenode->force_open();
3122 if (has_capability('moodle/course:update', $coursecontext)) {
3123 // Add the turn on/off settings
3124 $url = new moodle_url('/course/view.php', array('id'=>$course->id
, 'sesskey'=>sesskey()));
3125 if ($this->page
->user_is_editing()) {
3126 $url->param('edit', 'off');
3127 $editstring = get_string('turneditingoff');
3129 $url->param('edit', 'on');
3130 $editstring = get_string('turneditingon');
3132 $coursenode->add($editstring, $url, self
::TYPE_SETTING
, null, null, new pix_icon('i/edit', ''));
3134 if ($this->page
->user_is_editing()) {
3135 // Removed as per MDL-22732
3136 // $this->add_course_editing_links($course);
3139 // Add the course settings link
3140 $url = new moodle_url('/course/edit.php', array('id'=>$course->id
));
3141 $coursenode->add(get_string('editsettings'), $url, self
::TYPE_SETTING
, null, null, new pix_icon('i/settings', ''));
3143 // Add the course completion settings link
3144 if ($CFG->enablecompletion
&& $course->enablecompletion
) {
3145 $url = new moodle_url('/course/completion.php', array('id'=>$course->id
));
3146 $coursenode->add(get_string('completion', 'completion'), $url, self
::TYPE_SETTING
, null, null, new pix_icon('i/settings', ''));
3151 enrol_add_course_navigation($coursenode, $course);
3154 if (has_capability('moodle/filter:manage', $coursecontext) && count(filter_get_available_in_context($coursecontext))>0) {
3155 $url = new moodle_url('/filter/manage.php', array('contextid'=>$coursecontext->id
));
3156 $coursenode->add(get_string('filters', 'admin'), $url, self
::TYPE_SETTING
, null, null, new pix_icon('i/filter', ''));
3159 // Add view grade report is permitted
3160 $reportavailable = false;
3161 if (has_capability('moodle/grade:viewall', $coursecontext)) {
3162 $reportavailable = true;
3163 } else if (!empty($course->showgrades
)) {
3164 $reports = get_plugin_list('gradereport');
3165 if (is_array($reports) && count($reports)>0) { // Get all installed reports
3166 arsort($reports); // user is last, we want to test it first
3167 foreach ($reports as $plugin => $plugindir) {
3168 if (has_capability('gradereport/'.$plugin.':view', $coursecontext)) {
3169 //stop when the first visible plugin is found
3170 $reportavailable = true;
3176 if ($reportavailable) {
3177 $url = new moodle_url('/grade/report/index.php', array('id'=>$course->id
));
3178 $gradenode = $coursenode->add(get_string('grades'), $url, self
::TYPE_SETTING
, null, 'grades', new pix_icon('i/grades', ''));
3181 // Add outcome if permitted
3182 if (!empty($CFG->enableoutcomes
) && has_capability('moodle/course:update', $coursecontext)) {
3183 $url = new moodle_url('/grade/edit/outcome/course.php', array('id'=>$course->id
));
3184 $coursenode->add(get_string('outcomes', 'grades'), $url, self
::TYPE_SETTING
, null, 'outcomes', new pix_icon('i/outcomes', ''));
3187 // Backup this course
3188 if (has_capability('moodle/backup:backupcourse', $coursecontext)) {
3189 $url = new moodle_url('/backup/backup.php', array('id'=>$course->id
));
3190 $coursenode->add(get_string('backup'), $url, self
::TYPE_SETTING
, null, 'backup', new pix_icon('i/backup', ''));
3193 // Restore to this course
3194 if (has_capability('moodle/restore:restorecourse', $coursecontext)) {
3195 $url = new moodle_url('/backup/restorefile.php', array('contextid'=>$coursecontext->id
));
3196 $coursenode->add(get_string('restore'), $url, self
::TYPE_SETTING
, null, 'restore', new pix_icon('i/restore', ''));
3199 // Import data from other courses
3200 if (has_capability('moodle/restore:restoretargetimport', $coursecontext)) {
3201 $url = new moodle_url('/backup/import.php', array('id'=>$course->id
));
3202 $coursenode->add(get_string('import'), $url, self
::TYPE_SETTING
, null, 'import', new pix_icon('i/restore', ''));
3205 // Publish course on a hub
3206 if (has_capability('moodle/course:publish', $coursecontext)) {
3207 $url = new moodle_url('/course/publish/index.php', array('id'=>$course->id
));
3208 $coursenode->add(get_string('publish'), $url, self
::TYPE_SETTING
, null, 'publish', new pix_icon('i/publish', ''));
3211 // Reset this course
3212 if (has_capability('moodle/course:reset', $coursecontext)) {
3213 $url = new moodle_url('/course/reset.php', array('id'=>$course->id
));
3214 $coursenode->add(get_string('reset'), $url, self
::TYPE_SETTING
, null, null, new pix_icon('i/return', ''));
3218 require_once($CFG->dirroot
.'/question/editlib.php');
3219 question_extend_settings_navigation($coursenode, $coursecontext)->trim_if_empty();
3221 if (has_capability('moodle/course:update', $coursecontext)) {
3222 // Repository Instances
3223 if (!$this->cache
->cached('contexthasrepos'.$coursecontext->id
)) {
3224 require_once($CFG->dirroot
. '/repository/lib.php');
3225 $editabletypes = repository
::get_editable_types($coursecontext);
3226 $haseditabletypes = !empty($editabletypes);
3227 unset($editabletypes);
3228 $this->cache
->set('contexthasrepos'.$coursecontext->id
, $haseditabletypes);
3230 $haseditabletypes = $this->cache
->{'contexthasrepos'.$coursecontext->id
};
3232 if ($haseditabletypes) {
3233 $url = new moodle_url('/repository/manage_instances.php', array('contextid' => $coursecontext->id
));
3234 $coursenode->add(get_string('repositories'), $url, self
::TYPE_SETTING
, null, null, new pix_icon('i/repository', ''));
3239 if ($course->legacyfiles
== 2 and has_capability('moodle/course:managefiles', $coursecontext)) {
3240 // hidden in new courses and courses where legacy files were turned off
3241 $url = new moodle_url('/files/index.php', array('contextid'=>$coursecontext->id
));
3242 $coursenode->add(get_string('courselegacyfiles'), $url, self
::TYPE_SETTING
, null, 'coursefiles', new pix_icon('i/files', ''));
3247 $assumedrole = $this->in_alternative_role();
3248 if ($assumedrole !== false) {
3249 $roles[0] = get_string('switchrolereturn');
3251 if (has_capability('moodle/role:switchroles', $coursecontext)) {
3252 $availableroles = get_switchable_roles($coursecontext);
3253 if (is_array($availableroles)) {
3254 foreach ($availableroles as $key=>$role) {
3255 if ($assumedrole == (int)$key) {
3258 $roles[$key] = $role;
3262 if (is_array($roles) && count($roles)>0) {
3263 $switchroles = $this->add(get_string('switchroleto'));
3264 if ((count($roles)==1 && array_key_exists(0, $roles))||
$assumedrole!==false) {
3265 $switchroles->force_open();
3267 $returnurl = $this->page
->url
;
3268 $returnurl->param('sesskey', sesskey());
3269 foreach ($roles as $key => $name) {
3270 $url = new moodle_url('/course/switchrole.php', array('id'=>$course->id
,'sesskey'=>sesskey(), 'switchrole'=>$key, 'returnurl'=>$returnurl->out(false)));
3271 $switchroles->add($name, $url, self
::TYPE_SETTING
, null, $key, new pix_icon('i/roles', ''));
3274 // Return we are done
3279 * Adds branches and links to the settings navigation to add course activities
3282 * @param stdClass $course
3284 protected function add_course_editing_links($course) {
3287 require_once($CFG->dirroot
.'/course/lib.php');
3289 // Add `add` resources|activities branches
3290 $structurefile = $CFG->dirroot
.'/course/format/'.$course->format
.'/lib.php';
3291 if (file_exists($structurefile)) {
3292 require_once($structurefile);
3293 $requestkey = call_user_func('callback_'.$course->format
.'_request_key');
3294 $formatidentifier = optional_param($requestkey, 0, PARAM_INT
);
3296 $requestkey = get_string('section');
3297 $formatidentifier = optional_param($requestkey, 0, PARAM_INT
);
3300 $sections = get_all_sections($course->id
);
3302 $addresource = $this->add(get_string('addresource'));
3303 $addactivity = $this->add(get_string('addactivity'));
3304 if ($formatidentifier!==0) {
3305 $addresource->force_open();
3306 $addactivity->force_open();
3309 $this->get_course_modules($course);
3311 $textlib = textlib_get_instance();
3313 foreach ($sections as $section) {
3314 if ($formatidentifier !== 0 && $section->section
!= $formatidentifier) {
3317 $sectionurl = new moodle_url('/course/view.php', array('id'=>$course->id
, $requestkey=>$section->section
));
3318 if ($section->section
== 0) {
3319 $sectionresources = $addresource->add(get_string('course'), $sectionurl, self
::TYPE_SETTING
);
3320 $sectionactivities = $addactivity->add(get_string('course'), $sectionurl, self
::TYPE_SETTING
);
3322 $sectionname = get_section_name($course, $section);
3323 $sectionresources = $addresource->add($sectionname, $sectionurl, self
::TYPE_SETTING
);
3324 $sectionactivities = $addactivity->add($sectionname, $sectionurl, self
::TYPE_SETTING
);
3326 foreach ($resources as $value=>$resource) {
3327 $url = new moodle_url('/course/mod.php', array('id'=>$course->id
, 'sesskey'=>sesskey(), 'section'=>$section->section
));
3328 $pos = strpos($value, '&type=');
3330 $url->param('add', $textlib->substr($value, 0,$pos));
3331 $url->param('type', $textlib->substr($value, $pos+
6));
3333 $url->param('add', $value);
3335 $sectionresources->add($resource, $url, self
::TYPE_SETTING
);
3338 foreach ($activities as $activityname=>$activity) {
3339 if ($activity==='--') {
3343 if (strpos($activity, '--')===0) {
3344 $subbranch = $sectionactivities->add(trim($activity, '-'));
3347 $url = new moodle_url('/course/mod.php', array('id'=>$course->id
, 'sesskey'=>sesskey(), 'section'=>$section->section
));
3348 $pos = strpos($activityname, '&type=');
3350 $url->param('add', $textlib->substr($activityname, 0,$pos));
3351 $url->param('type', $textlib->substr($activityname, $pos+
6));
3353 $url->param('add', $activityname);
3355 if ($subbranch !== false) {
3356 $subbranch->add($activity, $url, self
::TYPE_SETTING
);
3358 $sectionactivities->add($activity, $url, self
::TYPE_SETTING
);
3365 * This function calls the module function to inject module settings into the
3366 * settings navigation tree.
3368 * This only gets called if there is a corrosponding function in the modules
3371 * For examples mod/forum/lib.php ::: forum_extend_settings_navigation()
3373 * @return navigation_node|false
3375 protected function load_module_settings() {
3378 if (!$this->page
->cm
&& $this->context
->contextlevel
== CONTEXT_MODULE
&& $this->context
->instanceid
) {
3379 $cm = get_coursemodule_from_id(false, $this->context
->instanceid
, 0, false, MUST_EXIST
);
3380 $this->page
->set_cm($cm, $this->page
->course
);
3383 $file = $CFG->dirroot
.'/mod/'.$this->page
->activityname
.'/lib.php';
3384 if (file_exists($file)) {
3385 require_once($file);
3388 $modulenode = $this->add(get_string('pluginadministration', $this->page
->activityname
));
3389 $modulenode->force_open();
3391 // Settings for the module
3392 if (has_capability('moodle/course:manageactivities', $this->page
->cm
->context
)) {
3393 $url = new moodle_url('/course/modedit.php', array('update' => $this->page
->cm
->id
, 'return' => true, 'sesskey' => sesskey()));
3394 $modulenode->add(get_string('editsettings'), $url, navigation_node
::TYPE_SETTING
, null, 'modedit');
3396 // Assign local roles
3397 if (count(get_assignable_roles($this->page
->cm
->context
))>0) {
3398 $url = new moodle_url('/'.$CFG->admin
.'/roles/assign.php', array('contextid'=>$this->page
->cm
->context
->id
));
3399 $modulenode->add(get_string('localroles', 'role'), $url, self
::TYPE_SETTING
, null, 'roleassign');
3402 if (has_capability('moodle/role:review', $this->page
->cm
->context
) or count(get_overridable_roles($this->page
->cm
->context
))>0) {
3403 $url = new moodle_url('/'.$CFG->admin
.'/roles/permissions.php', array('contextid'=>$this->page
->cm
->context
->id
));
3404 $modulenode->add(get_string('permissions', 'role'), $url, self
::TYPE_SETTING
, null, 'roleoverride');
3406 // Check role permissions
3407 if (has_any_capability(array('moodle/role:assign', 'moodle/role:safeoverride','moodle/role:override', 'moodle/role:assign'), $this->page
->cm
->context
)) {
3408 $url = new moodle_url('/'.$CFG->admin
.'/roles/check.php', array('contextid'=>$this->page
->cm
->context
->id
));
3409 $modulenode->add(get_string('checkpermissions', 'role'), $url, self
::TYPE_SETTING
, null, 'rolecheck');
3412 if (has_capability('moodle/filter:manage', $this->page
->cm
->context
) && count(filter_get_available_in_context($this->page
->cm
->context
))>0) {
3413 $url = new moodle_url('/filter/manage.php', array('contextid'=>$this->page
->cm
->context
->id
));
3414 $modulenode->add(get_string('filters', 'admin'), $url, self
::TYPE_SETTING
, null, 'filtermanage');
3417 if (has_capability('coursereport/log:view', get_context_instance(CONTEXT_COURSE
, $this->page
->cm
->course
))) {
3418 $url = new moodle_url('/course/report/log/index.php', array('chooselog'=>'1','id'=>$this->page
->cm
->course
,'modid'=>$this->page
->cm
->id
));
3419 $modulenode->add(get_string('logs'), $url, self
::TYPE_SETTING
, null, 'logreport');
3422 // Add a backup link
3423 $featuresfunc = $this->page
->activityname
.'_supports';
3424 if (function_exists($featuresfunc) && $featuresfunc(FEATURE_BACKUP_MOODLE2
) && has_capability('moodle/backup:backupactivity', $this->page
->cm
->context
)) {
3425 $url = new moodle_url('/backup/backup.php', array('id'=>$this->page
->cm
->course
, 'cm'=>$this->page
->cm
->id
));
3426 $modulenode->add(get_string('backup'), $url, self
::TYPE_SETTING
, null, 'backup');
3429 // Restore this activity
3430 $featuresfunc = $this->page
->activityname
.'_supports';
3431 if (function_exists($featuresfunc) && $featuresfunc(FEATURE_BACKUP_MOODLE2
) && has_capability('moodle/restore:restoreactivity', $this->page
->cm
->context
)) {
3432 $url = new moodle_url('/backup/restorefile.php', array('contextid'=>$this->page
->cm
->context
->id
));
3433 $modulenode->add(get_string('restore'), $url, self
::TYPE_SETTING
, null, 'restore');
3436 $function = $this->page
->activityname
.'_extend_settings_navigation';
3437 if (!function_exists($function)) {
3441 $function($this, $modulenode);
3443 // Remove the module node if there are no children
3444 if (empty($modulenode->children
)) {
3445 $modulenode->remove();
3452 * Loads the user settings block of the settings nav
3454 * This function is simply works out the userid and whether we need to load
3455 * just the current users profile settings, or the current user and the user the
3456 * current user is viewing.
3458 * This function has some very ugly code to work out the user, if anyone has
3459 * any bright ideas please feel free to intervene.
3461 * @param int $courseid The course id of the current course
3462 * @return navigation_node|false
3464 protected function load_user_settings($courseid=SITEID
) {
3465 global $USER, $FULLME, $CFG;
3467 if (isguestuser() ||
!isloggedin()) {
3471 $navusers = $this->page
->navigation
->get_extending_users();
3473 if (count($this->userstoextendfor
) > 0 ||
count($navusers) > 0) {
3475 foreach ($this->userstoextendfor
as $userid) {
3476 if ($userid == $USER->id
) {
3479 $node = $this->generate_user_settings($courseid, $userid, 'userviewingsettings');
3480 if (is_null($usernode)) {
3484 foreach ($navusers as $user) {
3485 if ($user->id
== $USER->id
) {
3488 $node = $this->generate_user_settings($courseid, $user->id
, 'userviewingsettings');
3489 if (is_null($usernode)) {
3493 $this->generate_user_settings($courseid, $USER->id
);
3495 $usernode = $this->generate_user_settings($courseid, $USER->id
);
3501 * Extends the settings navigation for the given user.
3503 * Note: This method gets called automatically if you call
3504 * $PAGE->navigation->extend_for_user($userid)
3506 * @param int $userid
3508 public function extend_for_user($userid) {
3511 if (!in_array($userid, $this->userstoextendfor
)) {
3512 $this->userstoextendfor
[] = $userid;
3513 if ($this->initialised
) {
3514 $this->generate_user_settings($this->page
->course
->id
, $userid, 'userviewingsettings');
3515 $children = array();
3516 foreach ($this->children
as $child) {
3517 $children[] = $child;
3519 array_unshift($children, array_pop($children));
3520 $this->children
= new navigation_node_collection();
3521 foreach ($children as $child) {
3522 $this->children
->add($child);
3529 * This function gets called by {@link load_user_settings()} and actually works out
3530 * what can be shown/done
3532 * @global moodle_database $DB
3533 * @param int $courseid The current course' id
3534 * @param int $userid The user id to load for
3535 * @param string $gstitle The string to pass to get_string for the branch title
3536 * @return navigation_node|false
3538 protected function generate_user_settings($courseid, $userid, $gstitle='usercurrentsettings') {
3539 global $DB, $CFG, $USER, $SITE;
3541 if ($courseid != SITEID
) {
3542 if (!empty($this->page
->course
->id
) && $this->page
->course
->id
== $courseid) {
3543 $course = $this->page
->course
;
3545 list($select, $join) = context_instance_preload_sql('c.id', CONTEXT_COURSE
, 'ctx');
3546 $sql = "SELECT c.* $select FROM {course} c $join WHERE c.id = :courseid";
3547 $course = $DB->get_record_sql($sql, array('courseid' => $courseid), MUST_EXIST
);
3548 context_instance_preload($course);
3554 $coursecontext = get_context_instance(CONTEXT_COURSE
, $course->id
); // Course context
3555 $systemcontext = get_system_context();
3556 $currentuser = ($USER->id
== $userid);
3560 $usercontext = get_context_instance(CONTEXT_USER
, $user->id
); // User context
3563 list($select, $join) = context_instance_preload_sql('u.id', CONTEXT_USER
, 'ctx');
3564 $sql = "SELECT u.* $select FROM {user} u $join WHERE u.id = :userid";
3565 $user = $DB->get_record_sql($sql, array('userid' => $userid), IGNORE_MISSING
);
3569 context_instance_preload($user);
3571 // Check that the user can view the profile
3572 $usercontext = get_context_instance(CONTEXT_USER
, $user->id
); // User context
3573 $canviewuser = has_capability('moodle/user:viewdetails', $usercontext);
3575 if ($course->id
== SITEID
) {
3576 if ($CFG->forceloginforprofiles
&& !has_coursecontact_role($user->id
) && !$canviewuser) { // Reduce possibility of "browsing" userbase at site level
3577 // Teachers can browse and be browsed at site level. If not forceloginforprofiles, allow access (bug #4366)
3581 $canviewusercourse = has_capability('moodle/user:viewdetails', $coursecontext);
3582 $canaccessallgroups = has_capability('moodle/site:accessallgroups', $coursecontext);
3583 if ((!$canviewusercourse && !$canviewuser) ||
!can_access_course($coursecontext, $user->id
)) {
3586 if (!$canaccessallgroups && groups_get_course_groupmode($course) == SEPARATEGROUPS
) {
3587 // If groups are in use, make sure we can see that group
3593 $fullname = fullname($user, has_capability('moodle/site:viewfullnames', $this->page
->context
));
3596 if ($gstitle != 'usercurrentsettings') {
3600 // Add a user setting branch
3601 $usersetting = $this->add(get_string($gstitle, 'moodle', $fullname), null, self
::TYPE_CONTAINER
, null, $key);
3602 $usersetting->id
= 'usersettings';
3603 if ($this->page
->context
->contextlevel
== CONTEXT_USER
&& $this->page
->context
->instanceid
== $user->id
) {
3604 // Automatically start by making it active
3605 $usersetting->make_active();
3608 // Check if the user has been deleted
3609 if ($user->deleted
) {
3610 if (!has_capability('moodle/user:update', $coursecontext)) {
3611 // We can't edit the user so just show the user deleted message
3612 $usersetting->add(get_string('userdeleted'), null, self
::TYPE_SETTING
);
3614 // We can edit the user so show the user deleted message and link it to the profile
3615 if ($course->id
== SITEID
) {
3616 $profileurl = new moodle_url('/user/profile.php', array('id'=>$user->id
));
3618 $profileurl = new moodle_url('/user/view.php', array('id'=>$user->id
, 'course'=>$course->id
));
3620 $usersetting->add(get_string('userdeleted'), $profileurl, self
::TYPE_SETTING
);
3625 $userauthplugin = false;
3626 if (!empty($user->auth
)) {
3627 $userauthplugin = get_auth_plugin($user->auth
);
3630 // Add the profile edit link
3631 if (isloggedin() && !isguestuser($user) && !is_mnet_remote_user($user)) {
3632 if (($currentuser ||
is_siteadmin($USER) ||
!is_siteadmin($user)) && has_capability('moodle/user:update', $systemcontext)) {
3633 $url = new moodle_url('/user/editadvanced.php', array('id'=>$user->id
, 'course'=>$course->id
));
3634 $usersetting->add(get_string('editmyprofile'), $url, self
::TYPE_SETTING
);
3635 } else if ((has_capability('moodle/user:editprofile', $usercontext) && !is_siteadmin($user)) ||
($currentuser && has_capability('moodle/user:editownprofile', $systemcontext))) {
3636 if ($userauthplugin && $userauthplugin->can_edit_profile()) {
3637 $url = $userauthplugin->edit_profile_url();
3639 $url = new moodle_url('/user/edit.php', array('id'=>$user->id
, 'course'=>$course->id
));
3641 $usersetting->add(get_string('editmyprofile'), $url, self
::TYPE_SETTING
);
3646 // Change password link
3647 if ($userauthplugin && $currentuser && !session_is_loggedinas() && !isguestuser() && has_capability('moodle/user:changeownpassword', $systemcontext) && $userauthplugin->can_change_password()) {
3648 $passwordchangeurl = $userauthplugin->change_password_url();
3649 if (empty($passwordchangeurl)) {
3650 $passwordchangeurl = new moodle_url('/login/change_password.php', array('id'=>$course->id
));
3652 $usersetting->add(get_string("changepassword"), $passwordchangeurl, self
::TYPE_SETTING
);
3655 // View the roles settings
3656 if (has_any_capability(array('moodle/role:assign', 'moodle/role:safeoverride','moodle/role:override', 'moodle/role:manage'), $usercontext)) {
3657 $roles = $usersetting->add(get_string('roles'), null, self
::TYPE_SETTING
);
3659 $url = new moodle_url('/admin/roles/usersroles.php', array('userid'=>$user->id
, 'courseid'=>$course->id
));
3660 $roles->add(get_string('thisusersroles', 'role'), $url, self
::TYPE_SETTING
);
3662 $assignableroles = get_assignable_roles($usercontext, ROLENAME_BOTH
);
3664 if (!empty($assignableroles)) {
3665 $url = new moodle_url('/admin/roles/assign.php', array('contextid'=>$usercontext->id
,'userid'=>$user->id
, 'courseid'=>$course->id
));
3666 $roles->add(get_string('assignrolesrelativetothisuser', 'role'), $url, self
::TYPE_SETTING
);
3669 if (has_capability('moodle/role:review', $usercontext) ||
count(get_overridable_roles($usercontext, ROLENAME_BOTH
))>0) {
3670 $url = new moodle_url('/admin/roles/permissions.php', array('contextid'=>$usercontext->id
,'userid'=>$user->id
, 'courseid'=>$course->id
));
3671 $roles->add(get_string('permissions', 'role'), $url, self
::TYPE_SETTING
);
3674 $url = new moodle_url('/admin/roles/check.php', array('contextid'=>$usercontext->id
,'userid'=>$user->id
, 'courseid'=>$course->id
));
3675 $roles->add(get_string('checkpermissions', 'role'), $url, self
::TYPE_SETTING
);
3679 if ($currentuser && !empty($CFG->enableportfolios
) && has_capability('moodle/portfolio:export', $systemcontext)) {
3680 require_once($CFG->libdir
. '/portfoliolib.php');
3681 if (portfolio_instances(true, false)) {
3682 $portfolio = $usersetting->add(get_string('portfolios', 'portfolio'), null, self
::TYPE_SETTING
);
3684 $url = new moodle_url('/user/portfolio.php', array('courseid'=>$course->id
));
3685 $portfolio->add(get_string('configure', 'portfolio'), $url, self
::TYPE_SETTING
);
3687 $url = new moodle_url('/user/portfoliologs.php', array('courseid'=>$course->id
));
3688 $portfolio->add(get_string('logs', 'portfolio'), $url, self
::TYPE_SETTING
);
3692 $enablemanagetokens = false;
3693 if (!empty($CFG->enablerssfeeds
)) {
3694 $enablemanagetokens = true;
3695 } else if (!is_siteadmin($USER->id
)
3696 && !empty($CFG->enablewebservices
)
3697 && has_capability('moodle/webservice:createtoken', get_system_context()) ) {
3698 $enablemanagetokens = true;
3701 if ($currentuser && $enablemanagetokens) {
3702 $url = new moodle_url('/user/managetoken.php', array('sesskey'=>sesskey()));
3703 $usersetting->add(get_string('securitykeys', 'webservice'), $url, self
::TYPE_SETTING
);
3707 if (!$currentuser && $usercontext->contextlevel
== CONTEXT_USER
) {
3708 if (!$this->cache
->cached('contexthasrepos'.$usercontext->id
)) {
3709 require_once($CFG->dirroot
. '/repository/lib.php');
3710 $editabletypes = repository
::get_editable_types($usercontext);
3711 $haseditabletypes = !empty($editabletypes);
3712 unset($editabletypes);
3713 $this->cache
->set('contexthasrepos'.$usercontext->id
, $haseditabletypes);
3715 $haseditabletypes = $this->cache
->{'contexthasrepos'.$usercontext->id
};
3717 if ($haseditabletypes) {
3718 $url = new moodle_url('/repository/manage_instances.php', array('contextid'=>$usercontext->id
));
3719 $usersetting->add(get_string('repositories', 'repository'), $url, self
::TYPE_SETTING
);
3724 if (($currentuser && has_capability('moodle/user:editownmessageprofile', $systemcontext)) ||
(!isguestuser($user) && has_capability('moodle/user:editmessageprofile', $usercontext) && !is_primary_admin($user->id
))) {
3725 $url = new moodle_url('/message/edit.php', array('id'=>$user->id
, 'course'=>$course->id
));
3726 $usersetting->add(get_string('editmymessage', 'message'), $url, self
::TYPE_SETTING
);
3730 if ($currentuser && !empty($CFG->bloglevel
)) {
3731 $blog = $usersetting->add(get_string('blogs', 'blog'), null, navigation_node
::TYPE_CONTAINER
, null, 'blogs');
3732 $blog->add(get_string('preferences', 'blog'), new moodle_url('/blog/preferences.php'), navigation_node
::TYPE_SETTING
);
3733 if (!empty($CFG->useexternalblogs
) && $CFG->maxexternalblogsperuser
> 0 && has_capability('moodle/blog:manageexternal', get_context_instance(CONTEXT_SYSTEM
))) {
3734 $blog->add(get_string('externalblogs', 'blog'), new moodle_url('/blog/external_blogs.php'), navigation_node
::TYPE_SETTING
);
3735 $blog->add(get_string('addnewexternalblog', 'blog'), new moodle_url('/blog/external_blog_edit.php'), navigation_node
::TYPE_SETTING
);
3740 if (!$user->deleted
and !$currentuser && !session_is_loggedinas() && has_capability('moodle/user:loginas', $coursecontext) && !is_siteadmin($user->id
)) {
3741 $url = new moodle_url('/course/loginas.php', array('id'=>$course->id
, 'user'=>$user->id
, 'sesskey'=>sesskey()));
3742 $usersetting->add(get_string('loginas'), $url, self
::TYPE_SETTING
);
3745 return $usersetting;
3749 * Loads block specific settings in the navigation
3751 * @return navigation_node
3753 protected function load_block_settings() {
3756 $blocknode = $this->add(print_context_name($this->context
));
3757 $blocknode->force_open();
3759 // Assign local roles
3760 $assignurl = new moodle_url('/'.$CFG->admin
.'/roles/assign.php', array('contextid'=>$this->context
->id
));
3761 $blocknode->add(get_string('assignroles', 'role'), $assignurl, self
::TYPE_SETTING
);
3764 if (has_capability('moodle/role:review', $this->context
) or count(get_overridable_roles($this->context
))>0) {
3765 $url = new moodle_url('/'.$CFG->admin
.'/roles/permissions.php', array('contextid'=>$this->context
->id
));
3766 $blocknode->add(get_string('permissions', 'role'), $url, self
::TYPE_SETTING
);
3768 // Check role permissions
3769 if (has_any_capability(array('moodle/role:assign', 'moodle/role:safeoverride','moodle/role:override', 'moodle/role:assign'), $this->context
)) {
3770 $url = new moodle_url('/'.$CFG->admin
.'/roles/check.php', array('contextid'=>$this->context
->id
));
3771 $blocknode->add(get_string('checkpermissions', 'role'), $url, self
::TYPE_SETTING
);
3778 * Loads category specific settings in the navigation
3780 * @return navigation_node
3782 protected function load_category_settings() {
3785 $categorynode = $this->add(print_context_name($this->context
));
3786 $categorynode->force_open();
3788 if (has_any_capability(array('moodle/category:manage', 'moodle/course:create'), $this->context
)) {
3789 $url = new moodle_url('/course/category.php', array('id'=>$this->context
->instanceid
, 'sesskey'=>sesskey()));
3790 if ($this->page
->user_is_editing()) {
3791 $url->param('categoryedit', '0');
3792 $editstring = get_string('turneditingoff');
3794 $url->param('categoryedit', '1');
3795 $editstring = get_string('turneditingon');
3797 $categorynode->add($editstring, $url, self
::TYPE_SETTING
, null, null, new pix_icon('i/edit', ''));
3800 if ($this->page
->user_is_editing() && has_capability('moodle/category:manage', $this->context
)) {
3801 $editurl = new moodle_url('/course/editcategory.php', array('id' => $this->context
->instanceid
));
3802 $categorynode->add(get_string('editcategorythis'), $editurl, self
::TYPE_SETTING
, null, 'edit', new pix_icon('i/edit', ''));
3804 $addsubcaturl = new moodle_url('/course/editcategory.php', array('parent' => $this->context
->instanceid
));
3805 $categorynode->add(get_string('addsubcategory'), $addsubcaturl, self
::TYPE_SETTING
, null, 'addsubcat', new pix_icon('i/withsubcat', ''));
3808 // Assign local roles
3809 if (has_capability('moodle/role:assign', $this->context
)) {
3810 $assignurl = new moodle_url('/'.$CFG->admin
.'/roles/assign.php', array('contextid'=>$this->context
->id
));
3811 $categorynode->add(get_string('assignroles', 'role'), $assignurl, self
::TYPE_SETTING
, null, 'roles', new pix_icon('i/roles', ''));
3815 if (has_capability('moodle/role:review', $this->context
) or count(get_overridable_roles($this->context
))>0) {
3816 $url = new moodle_url('/'.$CFG->admin
.'/roles/permissions.php', array('contextid'=>$this->context
->id
));
3817 $categorynode->add(get_string('permissions', 'role'), $url, self
::TYPE_SETTING
, null, 'permissions', new pix_icon('i/permissions', ''));
3819 // Check role permissions
3820 if (has_any_capability(array('moodle/role:assign', 'moodle/role:safeoverride','moodle/role:override', 'moodle/role:assign'), $this->context
)) {
3821 $url = new moodle_url('/'.$CFG->admin
.'/roles/check.php', array('contextid'=>$this->context
->id
));
3822 $categorynode->add(get_string('checkpermissions', 'role'), $url, self
::TYPE_SETTING
, null, 'checkpermissions', new pix_icon('i/checkpermissions', ''));
3826 if (has_capability('moodle/cohort:manage', $this->context
) or has_capability('moodle/cohort:view', $this->context
)) {
3827 $categorynode->add(get_string('cohorts', 'cohort'), new moodle_url('/cohort/index.php', array('contextid' => $this->context
->id
)), self
::TYPE_SETTING
, null, 'cohort', new pix_icon('i/cohort', ''));
3831 if (has_capability('moodle/filter:manage', $this->context
) && count(filter_get_available_in_context($this->context
))>0) {
3832 $url = new moodle_url('/filter/manage.php', array('contextid'=>$this->context
->id
));
3833 $categorynode->add(get_string('filters', 'admin'), $url, self
::TYPE_SETTING
, null, 'filters', new pix_icon('i/filter', ''));
3836 return $categorynode;
3840 * Determine whether the user is assuming another role
3842 * This function checks to see if the user is assuming another role by means of
3843 * role switching. In doing this we compare each RSW key (context path) against
3844 * the current context path. This ensures that we can provide the switching
3845 * options against both the course and any page shown under the course.
3847 * @return bool|int The role(int) if the user is in another role, false otherwise
3849 protected function in_alternative_role() {
3851 if (!empty($USER->access
['rsw']) && is_array($USER->access
['rsw'])) {
3852 if (!empty($this->page
->context
) && !empty($USER->access
['rsw'][$this->page
->context
->path
])) {
3853 return $USER->access
['rsw'][$this->page
->context
->path
];
3855 foreach ($USER->access
['rsw'] as $key=>$role) {
3856 if (strpos($this->context
->path
,$key)===0) {
3865 * This function loads all of the front page settings into the settings navigation.
3866 * This function is called when the user is on the front page, or $COURSE==$SITE
3867 * @return navigation_node
3869 protected function load_front_page_settings($forceopen = false) {
3872 $course = clone($SITE);
3873 $coursecontext = get_context_instance(CONTEXT_COURSE
, $course->id
); // Course context
3875 $frontpage = $this->add(get_string('frontpagesettings'), null, self
::TYPE_SETTING
, null, 'frontpage');
3877 $frontpage->force_open();
3879 $frontpage->id
= 'frontpagesettings';
3881 if (has_capability('moodle/course:update', $coursecontext)) {
3883 // Add the turn on/off settings
3884 $url = new moodle_url('/course/view.php', array('id'=>$course->id
, 'sesskey'=>sesskey()));
3885 if ($this->page
->user_is_editing()) {
3886 $url->param('edit', 'off');
3887 $editstring = get_string('turneditingoff');
3889 $url->param('edit', 'on');
3890 $editstring = get_string('turneditingon');
3892 $frontpage->add($editstring, $url, self
::TYPE_SETTING
, null, null, new pix_icon('i/edit', ''));
3894 // Add the course settings link
3895 $url = new moodle_url('/admin/settings.php', array('section'=>'frontpagesettings'));
3896 $frontpage->add(get_string('editsettings'), $url, self
::TYPE_SETTING
, null, null, new pix_icon('i/settings', ''));
3900 enrol_add_course_navigation($frontpage, $course);
3903 if (has_capability('moodle/filter:manage', $coursecontext) && count(filter_get_available_in_context($coursecontext))>0) {
3904 $url = new moodle_url('/filter/manage.php', array('contextid'=>$coursecontext->id
));
3905 $frontpage->add(get_string('filters', 'admin'), $url, self
::TYPE_SETTING
, null, null, new pix_icon('i/filter', ''));
3908 // Backup this course
3909 if (has_capability('moodle/backup:backupcourse', $coursecontext)) {
3910 $url = new moodle_url('/backup/backup.php', array('id'=>$course->id
));
3911 $frontpage->add(get_string('backup'), $url, self
::TYPE_SETTING
, null, null, new pix_icon('i/backup', ''));
3914 // Restore to this course
3915 if (has_capability('moodle/restore:restorecourse', $coursecontext)) {
3916 $url = new moodle_url('/backup/restorefile.php', array('contextid'=>$coursecontext->id
));
3917 $frontpage->add(get_string('restore'), $url, self
::TYPE_SETTING
, null, null, new pix_icon('i/restore', ''));
3921 $questioncaps = array('moodle/question:add',
3922 'moodle/question:editmine',
3923 'moodle/question:editall',
3924 'moodle/question:viewmine',
3925 'moodle/question:viewall',
3926 'moodle/question:movemine',
3927 'moodle/question:moveall');
3928 if (has_any_capability($questioncaps, $this->context
)) {
3929 $questionlink = $CFG->wwwroot
.'/question/edit.php';
3930 } else if (has_capability('moodle/question:managecategory', $this->context
)) {
3931 $questionlink = $CFG->wwwroot
.'/question/category.php';
3933 if (isset($questionlink)) {
3934 $url = new moodle_url($questionlink, array('courseid'=>$course->id
));
3935 $frontpage->add(get_string('questions','quiz'), $url, self
::TYPE_SETTING
, null, null, new pix_icon('i/questions', ''));
3939 if ($course->legacyfiles
== 2 and has_capability('moodle/course:managefiles', $this->context
)) {
3940 //hiden in new installs
3941 $url = new moodle_url('/files/index.php', array('contextid'=>$coursecontext->id
, 'itemid'=>0, 'component' => 'course', 'filearea'=>'legacy'));
3942 $frontpage->add(get_string('sitelegacyfiles'), $url, self
::TYPE_SETTING
, null, null, new pix_icon('i/files', ''));
3948 * This function marks the cache as volatile so it is cleared during shutdown
3950 public function clear_cache() {
3951 $this->cache
->volatile();
3956 * Simple class used to output a navigation branch in XML
3958 * @package moodlecore
3959 * @subpackage navigation
3960 * @copyright 2009 Sam Hemelryk
3961 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
3963 class navigation_json
{
3965 protected $nodetype = array('node','branch');
3967 protected $expandable = array();
3969 * Turns a branch and all of its children into XML
3971 * @param navigation_node $branch
3972 * @return string XML string
3974 public function convert($branch) {
3975 $xml = $this->convert_child($branch);
3979 * Set the expandable items in the array so that we have enough information
3980 * to attach AJAX events
3981 * @param array $expandable
3983 public function set_expandable($expandable) {
3984 foreach ($expandable as $node) {
3985 $this->expandable
[$node['key'].':'.$node['type']] = $node;
3989 * Recusively converts a child node and its children to XML for output
3991 * @param navigation_node $child The child to convert
3992 * @param int $depth Pointlessly used to track the depth of the XML structure
3993 * @return string JSON
3995 protected function convert_child($child, $depth=1) {
3996 if (!$child->display
) {
3999 $attributes = array();
4000 $attributes['id'] = $child->id
;
4001 $attributes['name'] = $child->text
;
4002 $attributes['type'] = $child->type
;
4003 $attributes['key'] = $child->key
;
4004 $attributes['class'] = $child->get_css_type();
4006 if ($child->icon
instanceof pix_icon
) {
4007 $attributes['icon'] = array(
4008 'component' => $child->icon
->component
,
4009 'pix' => $child->icon
->pix
,
4011 foreach ($child->icon
->attributes
as $key=>$value) {
4012 if ($key == 'class') {
4013 $attributes['icon']['classes'] = explode(' ', $value);
4014 } else if (!array_key_exists($key, $attributes['icon'])) {
4015 $attributes['icon'][$key] = $value;
4019 } else if (!empty($child->icon
)) {
4020 $attributes['icon'] = (string)$child->icon
;
4023 if ($child->forcetitle ||
$child->title
!== $child->text
) {
4024 $attributes['title'] = htmlentities($child->title
);
4026 if (array_key_exists($child->key
.':'.$child->type
, $this->expandable
)) {
4027 $attributes['expandable'] = $child->key
;
4028 $child->add_class($this->expandable
[$child->key
.':'.$child->type
]['id']);
4031 if (count($child->classes
)>0) {
4032 $attributes['class'] .= ' '.join(' ',$child->classes
);
4034 if (is_string($child->action
)) {
4035 $attributes['link'] = $child->action
;
4036 } else if ($child->action
instanceof moodle_url
) {
4037 $attributes['link'] = $child->action
->out();
4039 $attributes['hidden'] = ($child->hidden
);
4040 $attributes['haschildren'] = ($child->children
->count()>0 ||
$child->type
== navigation_node
::TYPE_CATEGORY
);
4042 if ($child->children
->count() > 0) {
4043 $attributes['children'] = array();
4044 foreach ($child->children
as $subchild) {
4045 $attributes['children'][] = $this->convert_child($subchild, $depth+
1);
4052 return json_encode($attributes);
4058 * The cache class used by global navigation and settings navigation to cache bits
4059 * and bobs that are used during their generation.
4061 * It is basically an easy access point to session with a bit of smarts to make
4062 * sure that the information that is cached is valid still.
4066 * if (!$cache->viewdiscussion()) {
4067 * // Code to do stuff and produce cachable content
4068 * $cache->viewdiscussion = has_capability('mod/forum:viewdiscussion', $coursecontext);
4070 * $content = $cache->viewdiscussion;
4073 * @package moodlecore
4074 * @subpackage navigation
4075 * @copyright 2009 Sam Hemelryk
4076 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
4078 class navigation_cache
{
4080 protected $creation;
4087 /** @var stdClass */
4088 protected $currentcontext;
4090 const CACHETIME
= 0;
4092 const CACHEUSERID
= 1;
4094 const CACHEVALUE
= 2;
4095 /** @var null|array An array of navigation cache areas to expire on shutdown */
4096 public static $volatilecaches;
4099 * Contructor for the cache. Requires two arguments
4101 * @param string $area The string to use to segregate this particular cache
4102 * it can either be unique to start a fresh cache or if you want
4103 * to share a cache then make it the string used in the original
4105 * @param int $timeout The number of seconds to time the information out after
4107 public function __construct($area, $timeout=1800) {
4108 $this->creation
= time();
4109 $this->area
= $area;
4110 $this->timeout
= time() - $timeout;
4111 if (rand(0,100) === 0) {
4112 $this->garbage_collection();
4117 * Used to set up the cache within the SESSION.
4119 * This is called for each access and ensure that we don't put anything into the session before
4122 protected function ensure_session_cache_initialised() {
4124 if (empty($this->session
)) {
4125 if (!isset($SESSION->navcache
)) {
4126 $SESSION->navcache
= new stdClass
;
4128 if (!isset($SESSION->navcache
->{$this->area
})) {
4129 $SESSION->navcache
->{$this->area
} = array();
4131 $this->session
= &$SESSION->navcache
->{$this->area
};
4136 * Magic Method to retrieve something by simply calling using = cache->key
4138 * @param mixed $key The identifier for the information you want out again
4139 * @return void|mixed Either void or what ever was put in
4141 public function __get($key) {
4142 if (!$this->cached($key)) {
4145 $information = $this->session
[$key][self
::CACHEVALUE
];
4146 return unserialize($information);
4150 * Magic method that simply uses {@link set();} to store something in the cache
4152 * @param string|int $key
4153 * @param mixed $information
4155 public function __set($key, $information) {
4156 $this->set($key, $information);
4160 * Sets some information against the cache (session) for later retrieval
4162 * @param string|int $key
4163 * @param mixed $information
4165 public function set($key, $information) {
4167 $this->ensure_session_cache_initialised();
4168 $information = serialize($information);
4169 $this->session
[$key]= array(self
::CACHETIME
=>time(), self
::CACHEUSERID
=>$USER->id
, self
::CACHEVALUE
=>$information);
4172 * Check the existence of the identifier in the cache
4174 * @param string|int $key
4177 public function cached($key) {
4179 $this->ensure_session_cache_initialised();
4180 if (!array_key_exists($key, $this->session
) ||
!is_array($this->session
[$key]) ||
$this->session
[$key][self
::CACHEUSERID
]!=$USER->id ||
$this->session
[$key][self
::CACHETIME
] < $this->timeout
) {
4186 * Compare something to it's equivilant in the cache
4188 * @param string $key
4189 * @param mixed $value
4190 * @param bool $serialise Whether to serialise the value before comparison
4191 * this should only be set to false if the value is already
4193 * @return bool If the value is the same false if it is not set or doesn't match
4195 public function compare($key, $value, $serialise = true) {
4196 if ($this->cached($key)) {
4198 $value = serialize($value);
4200 if ($this->session
[$key][self
::CACHEVALUE
] === $value) {
4207 * Wipes the entire cache, good to force regeneration
4209 public function clear() {
4211 unset($SESSION->navcache
);
4212 $this->session
= null;
4215 * Checks all cache entries and removes any that have expired, good ole cleanup
4217 protected function garbage_collection() {
4218 if (empty($this->session
)) {
4221 foreach ($this->session
as $key=>$cachedinfo) {
4222 if (is_array($cachedinfo) && $cachedinfo[self
::CACHETIME
]<$this->timeout
) {
4223 unset($this->session
[$key]);
4229 * Marks the cache as being volatile (likely to change)
4231 * Any caches marked as volatile will be destroyed at the on shutdown by
4232 * {@link navigation_node::destroy_volatile_caches()} which is registered
4233 * as a shutdown function if any caches are marked as volatile.
4235 * @param bool $setting True to destroy the cache false not too
4237 public function volatile($setting = true) {
4238 if (self
::$volatilecaches===null) {
4239 self
::$volatilecaches = array();
4240 register_shutdown_function(array('navigation_cache','destroy_volatile_caches'));
4244 self
::$volatilecaches[$this->area
] = $this->area
;
4245 } else if (array_key_exists($this->area
, self
::$volatilecaches)) {
4246 unset(self
::$volatilecaches[$this->area
]);
4251 * Destroys all caches marked as volatile
4253 * This function is static and works in conjunction with the static volatilecaches
4254 * property of navigation cache.
4255 * Because this function is static it manually resets the cached areas back to an
4258 public static function destroy_volatile_caches() {
4260 if (is_array(self
::$volatilecaches) && count(self
::$volatilecaches)>0) {
4261 foreach (self
::$volatilecaches as $area) {
4262 $SESSION->navcache
->{$area} = array();
4265 $SESSION->navcache
= new stdClass
;