MDL-36323 usability: New icon names to assign and switch roles
[moodle.git] / lib / blocklib.php
1 <?php
3 // This file is part of Moodle - http://moodle.org/
4 //
5 // Moodle is free software: you can redistribute it and/or modify
6 // it under the terms of the GNU General Public License as published by
7 // the Free Software Foundation, either version 3 of the License, or
8 // (at your option) any later version.
9 //
10 // Moodle is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
18 /**
19  * Block Class and Functions
20  *
21  * This file defines the {@link block_manager} class,
22  *
23  * @package    core
24  * @subpackage block
25  * @copyright  1999 onwards Martin Dougiamas  http://dougiamas.com
26  * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
27  */
29 defined('MOODLE_INTERNAL') || die();
31 /**#@+
32  * @deprecated since Moodle 2.0. No longer used.
33  */
34 define('BLOCK_MOVE_LEFT',   0x01);
35 define('BLOCK_MOVE_RIGHT',  0x02);
36 define('BLOCK_MOVE_UP',     0x04);
37 define('BLOCK_MOVE_DOWN',   0x08);
38 define('BLOCK_CONFIGURE',   0x10);
39 /**#@-*/
41 /**#@+
42  * Default names for the block regions in the standard theme.
43  */
44 define('BLOCK_POS_LEFT',  'side-pre');
45 define('BLOCK_POS_RIGHT', 'side-post');
46 /**#@-*/
48 /**#@+
49  * @deprecated since Moodle 2.0. No longer used.
50  */
51 define('BLOCKS_PINNED_TRUE',0);
52 define('BLOCKS_PINNED_FALSE',1);
53 define('BLOCKS_PINNED_BOTH',2);
54 /**#@-*/
56 define('BUI_CONTEXTS_FRONTPAGE_ONLY', 0);
57 define('BUI_CONTEXTS_FRONTPAGE_SUBS', 1);
58 define('BUI_CONTEXTS_ENTIRE_SITE', 2);
60 define('BUI_CONTEXTS_CURRENT', 0);
61 define('BUI_CONTEXTS_CURRENT_SUBS', 1);
63 /**
64  * Exception thrown when someone tried to do something with a block that does
65  * not exist on a page.
66  *
67  * @copyright 2009 Tim Hunt
68  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
69  * @since     Moodle 2.0
70  */
71 class block_not_on_page_exception extends moodle_exception {
72     /**
73      * Constructor
74      * @param int $instanceid the block instance id of the block that was looked for.
75      * @param object $page the current page.
76      */
77     public function __construct($instanceid, $page) {
78         $a = new stdClass;
79         $a->instanceid = $instanceid;
80         $a->url = $page->url->out();
81         parent::__construct('blockdoesnotexistonpage', '', $page->url->out(), $a);
82     }
83 }
85 /**
86  * This class keeps track of the block that should appear on a moodle_page.
87  *
88  * The page to work with as passed to the constructor.
89  *
90  * @copyright 2009 Tim Hunt
91  * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
92  * @since     Moodle 2.0
93  */
94 class block_manager {
95     /**
96      * The UI normally only shows block weights between -MAX_WEIGHT and MAX_WEIGHT,
97      * although other weights are valid.
98      */
99     const MAX_WEIGHT = 10;
101 /// Field declarations =========================================================
103     /**
104      * the moodle_page we are managing blocks for.
105      * @var moodle_page
106      */
107     protected $page;
109     /** @var array region name => 1.*/
110     protected $regions = array();
112     /** @var string the region where new blocks are added.*/
113     protected $defaultregion = null;
115     /** @var array will be $DB->get_records('blocks') */
116     protected $allblocks = null;
118     /**
119      * @var array blocks that this user can add to this page. Will be a subset
120      * of $allblocks, but with array keys block->name. Access this via the
121      * {@link get_addable_blocks()} method to ensure it is lazy-loaded.
122      */
123     protected $addableblocks = null;
125     /**
126      * Will be an array region-name => array(db rows loaded in load_blocks);
127      * @var array
128      */
129     protected $birecordsbyregion = null;
131     /**
132      * array region-name => array(block objects); populated as necessary by
133      * the ensure_instances_exist method.
134      * @var array
135      */
136     protected $blockinstances = array();
138     /**
139      * array region-name => array(block_contents objects) what actually needs to
140      * be displayed in each region.
141      * @var array
142      */
143     protected $visibleblockcontent = array();
145     /**
146      * array region-name => array(block_contents objects) extra block-like things
147      * to be displayed in each region, before the real blocks.
148      * @var array
149      */
150     protected $extracontent = array();
152     /**
153      * Used by the block move id, to track whether a block is currently being moved.
154      *
155      * When you click on the move icon of a block, first the page needs to reload with
156      * extra UI for choosing a new position for a particular block. In that situation
157      * this field holds the id of the block being moved.
158      *
159      * @var integer|null
160      */
161     protected $movingblock = null;
163     /**
164      * Show only fake blocks
165      */
166     protected $fakeblocksonly = false;
168 /// Constructor ================================================================
170     /**
171      * Constructor.
172      * @param object $page the moodle_page object object we are managing the blocks for,
173      * or a reasonable faxilimily. (See the comment at the top of this class
174      * and {@link http://en.wikipedia.org/wiki/Duck_typing})
175      */
176     public function __construct($page) {
177         $this->page = $page;
178     }
180 /// Getter methods =============================================================
182     /**
183      * Get an array of all region names on this page where a block may appear
184      *
185      * @return array the internal names of the regions on this page where block may appear.
186      */
187     public function get_regions() {
188         if (is_null($this->defaultregion)) {
189             $this->page->initialise_theme_and_output();
190         }
191         return array_keys($this->regions);
192     }
194     /**
195      * Get the region name of the region blocks are added to by default
196      *
197      * @return string the internal names of the region where new blocks are added
198      * by default, and where any blocks from an unrecognised region are shown.
199      * (Imagine that blocks were added with one theme selected, then you switched
200      * to a theme with different block positions.)
201      */
202     public function get_default_region() {
203         $this->page->initialise_theme_and_output();
204         return $this->defaultregion;
205     }
207     /**
208      * The list of block types that may be added to this page.
209      *
210      * @return array block name => record from block table.
211      */
212     public function get_addable_blocks() {
213         $this->check_is_loaded();
215         if (!is_null($this->addableblocks)) {
216             return $this->addableblocks;
217         }
219         // Lazy load.
220         $this->addableblocks = array();
222         $allblocks = blocks_get_record();
223         if (empty($allblocks)) {
224             return $this->addableblocks;
225         }
227         $unaddableblocks = self::get_undeletable_block_types();
228         $pageformat = $this->page->pagetype;
229         foreach($allblocks as $block) {
230             if (!$bi = block_instance($block->name)) {
231                 continue;
232             }
233             if ($block->visible && !in_array($block->name, $unaddableblocks) &&
234                     ($bi->instance_allow_multiple() || !$this->is_block_present($block->name)) &&
235                     blocks_name_allowed_in_format($block->name, $pageformat) &&
236                     $bi->user_can_addto($this->page)) {
237                 $this->addableblocks[$block->name] = $block;
238             }
239         }
241         return $this->addableblocks;
242     }
244     /**
245      * Given a block name, find out of any of them are currently present in the page
247      * @param string $blockname - the basic name of a block (eg "navigation")
248      * @return boolean - is there one of these blocks in the current page?
249      */
250     public function is_block_present($blockname) {
251         if (empty($this->blockinstances)) {
252             return false;
253         }
255         foreach ($this->blockinstances as $region) {
256             foreach ($region as $instance) {
257                 if (empty($instance->instance->blockname)) {
258                     continue;
259                 }
260                 if ($instance->instance->blockname == $blockname) {
261                     return true;
262                 }
263             }
264         }
265         return false;
266     }
268     /**
269      * Find out if a block type is known by the system
270      *
271      * @param string $blockname the name of the type of block.
272      * @param boolean $includeinvisible if false (default) only check 'visible' blocks, that is, blocks enabled by the admin.
273      * @return boolean true if this block in installed.
274      */
275     public function is_known_block_type($blockname, $includeinvisible = false) {
276         $blocks = $this->get_installed_blocks();
277         foreach ($blocks as $block) {
278             if ($block->name == $blockname && ($includeinvisible || $block->visible)) {
279                 return true;
280             }
281         }
282         return false;
283     }
285     /**
286      * Find out if a region exists on a page
287      *
288      * @param string $region a region name
289      * @return boolean true if this region exists on this page.
290      */
291     public function is_known_region($region) {
292         return array_key_exists($region, $this->regions);
293     }
295     /**
296      * Get an array of all blocks within a given region
297      *
298      * @param string $region a block region that exists on this page.
299      * @return array of block instances.
300      */
301     public function get_blocks_for_region($region) {
302         $this->check_is_loaded();
303         $this->ensure_instances_exist($region);
304         return $this->blockinstances[$region];
305     }
307     /**
308      * Returns an array of block content objects that exist in a region
309      *
310      * @param string $region a block region that exists on this page.
311      * @return array of block block_contents objects for all the blocks in a region.
312      */
313     public function get_content_for_region($region, $output) {
314         $this->check_is_loaded();
315         $this->ensure_content_created($region, $output);
316         return $this->visibleblockcontent[$region];
317     }
319     /**
320      * Helper method used by get_content_for_region.
321      * @param string $region region name
322      * @param float $weight weight. May be fractional, since you may want to move a block
323      * between ones with weight 2 and 3, say ($weight would be 2.5).
324      * @return string URL for moving block $this->movingblock to this position.
325      */
326     protected function get_move_target_url($region, $weight) {
327         return new moodle_url($this->page->url, array('bui_moveid' => $this->movingblock,
328                 'bui_newregion' => $region, 'bui_newweight' => $weight, 'sesskey' => sesskey()));
329     }
331     /**
332      * Determine whether a region contains anything. (Either any real blocks, or
333      * the add new block UI.)
334      *
335      * (You may wonder why the $output parameter is required. Unfortunately,
336      * because of the way that blocks work, the only reliable way to find out
337      * if a block will be visible is to get the content for output, and to
338      * get the content, you need a renderer. Fortunately, this is not a
339      * performance problem, because we cache the output that is generated, and
340      * in almost every case where we call region_has_content, we are about to
341      * output the blocks anyway, so we are not doing wasted effort.)
342      *
343      * @param string $region a block region that exists on this page.
344      * @param object $output a core_renderer. normally the global $OUTPUT.
345      * @return boolean Whether there is anything in this region.
346      */
347     public function region_has_content($region, $output) {
349         if (!$this->is_known_region($region)) {
350             return false;
351         }
352         $this->check_is_loaded();
353         $this->ensure_content_created($region, $output);
354         // if ($this->page->user_is_editing() && $this->page->user_can_edit_blocks()) {
355         // Mark Nielsen's patch - part 1
356         if ($this->page->user_is_editing() && $this->page->user_can_edit_blocks() && $this->movingblock) {
357             // If editing is on, we need all the block regions visible, for the
358             // move blocks UI.
359             return true;
360         }
361         return !empty($this->visibleblockcontent[$region]) || !empty($this->extracontent[$region]);
362     }
364     /**
365      * Get an array of all of the installed blocks.
366      *
367      * @return array contents of the block table.
368      */
369     public function get_installed_blocks() {
370         global $DB;
371         if (is_null($this->allblocks)) {
372             $this->allblocks = $DB->get_records('block');
373         }
374         return $this->allblocks;
375     }
377     /**
378      * @return array names of block types that cannot be added or deleted. E.g. array('navigation','settings').
379      */
380     public static function get_undeletable_block_types() {
381         global $CFG;
383         if (!isset($CFG->undeletableblocktypes) || (!is_array($CFG->undeletableblocktypes) && !is_string($CFG->undeletableblocktypes))) {
384             return array('navigation','settings');
385         } else if (is_string($CFG->undeletableblocktypes)) {
386             return explode(',', $CFG->undeletableblocktypes);
387         } else {
388             return $CFG->undeletableblocktypes;
389         }
390     }
392 /// Setter methods =============================================================
394     /**
395      * Add a region to a page
396      *
397      * @param string $region add a named region where blocks may appear on the
398      * current page. This is an internal name, like 'side-pre', not a string to
399      * display in the UI.
400      */
401     public function add_region($region) {
402         $this->check_not_yet_loaded();
403         $this->regions[$region] = 1;
404     }
406     /**
407      * Add an array of regions
408      * @see add_region()
409      *
410      * @param array $regions this utility method calls add_region for each array element.
411      */
412     public function add_regions($regions) {
413         foreach ($regions as $region) {
414             $this->add_region($region);
415         }
416     }
418     /**
419      * Set the default region for new blocks on the page
420      *
421      * @param string $defaultregion the internal names of the region where new
422      * blocks should be added by default, and where any blocks from an
423      * unrecognised region are shown.
424      */
425     public function set_default_region($defaultregion) {
426         $this->check_not_yet_loaded();
427         if ($defaultregion) {
428             $this->check_region_is_known($defaultregion);
429         }
430         $this->defaultregion = $defaultregion;
431     }
433     /**
434      * Add something that looks like a block, but which isn't an actual block_instance,
435      * to this page.
436      *
437      * @param block_contents $bc the content of the block-like thing.
438      * @param string $region a block region that exists on this page.
439      */
440     public function add_fake_block($bc, $region) {
441         $this->page->initialise_theme_and_output();
442         if (!$this->is_known_region($region)) {
443             $region = $this->get_default_region();
444         }
445         if (array_key_exists($region, $this->visibleblockcontent)) {
446             throw new coding_exception('block_manager has already prepared the blocks in region ' .
447                     $region . 'for output. It is too late to add a fake block.');
448         }
449         $this->extracontent[$region][] = $bc;
450     }
452     /**
453      * When the block_manager class was created, the {@link add_fake_block()}
454      * was called add_pretend_block, which is inconsisted with
455      * {@link show_only_fake_blocks()}. To fix this inconsistency, this method
456      * was renamed to add_fake_block. Please update your code.
457      * @param block_contents $bc the content of the block-like thing.
458      * @param string $region a block region that exists on this page.
459      */
460     public function add_pretend_block($bc, $region) {
461         debugging(DEBUG_DEVELOPER, 'add_pretend_block has been renamed to add_fake_block. Please rename the method call in your code.');
462         $this->add_fake_block($bc, $region);
463     }
465     /**
466      * Checks to see whether all of the blocks within the given region are docked
467      *
468      * @see region_uses_dock
469      * @param string $region
470      * @return bool True if all of the blocks within that region are docked
471      */
472     public function region_completely_docked($region, $output) {
473         global $CFG;
474         // If theme doesn't allow docking or allowblockstodock is not set, then return.
475         if (!$this->page->theme->enable_dock || empty($CFG->allowblockstodock)) {
476             return false;
477         }
479         // Do not dock the region when the user attemps to move a block.
480         if ($this->movingblock) {
481             return false;
482         }
484         $this->check_is_loaded();
485         $this->ensure_content_created($region, $output);
486         foreach($this->visibleblockcontent[$region] as $instance) {
487             if (!empty($instance->content) && !get_user_preferences('docked_block_instance_'.$instance->blockinstanceid, 0)) {
488                 return false;
489             }
490         }
491         return true;
492     }
494     /**
495      * Checks to see whether any of the blocks within the given regions are docked
496      *
497      * @see region_completely_docked
498      * @param array|string $regions array of regions (or single region)
499      * @return bool True if any of the blocks within that region are docked
500      */
501     public function region_uses_dock($regions, $output) {
502         if (!$this->page->theme->enable_dock) {
503             return false;
504         }
505         $this->check_is_loaded();
506         foreach((array)$regions as $region) {
507             $this->ensure_content_created($region, $output);
508             foreach($this->visibleblockcontent[$region] as $instance) {
509                 if(!empty($instance->content) && get_user_preferences('docked_block_instance_'.$instance->blockinstanceid, 0)) {
510                     return true;
511                 }
512             }
513         }
514         return false;
515     }
517 /// Actions ====================================================================
519     /**
520      * This method actually loads the blocks for our page from the database.
521      *
522      * @param boolean|null $includeinvisible
523      *      null (default) - load hidden blocks if $this->page->user_is_editing();
524      *      true - load hidden blocks.
525      *      false - don't load hidden blocks.
526      */
527     public function load_blocks($includeinvisible = null) {
528         global $DB, $CFG;
530         if (!is_null($this->birecordsbyregion)) {
531             // Already done.
532             return;
533         }
535         if ($CFG->version < 2009050619) {
536             // Upgrade/install not complete. Don't try too show any blocks.
537             $this->birecordsbyregion = array();
538             return;
539         }
541         // Ensure we have been initialised.
542         if (is_null($this->defaultregion)) {
543             $this->page->initialise_theme_and_output();
544             // If there are still no block regions, then there are no blocks on this page.
545             if (empty($this->regions)) {
546                 $this->birecordsbyregion = array();
547                 return;
548             }
549         }
551         // Check if we need to load normal blocks
552         if ($this->fakeblocksonly) {
553             $this->birecordsbyregion = $this->prepare_per_region_arrays();
554             return;
555         }
557         if (is_null($includeinvisible)) {
558             $includeinvisible = $this->page->user_is_editing();
559         }
560         if ($includeinvisible) {
561             $visiblecheck = '';
562         } else {
563             $visiblecheck = 'AND (bp.visible = 1 OR bp.visible IS NULL)';
564         }
566         $context = $this->page->context;
567         $contexttest = 'bi.parentcontextid = :contextid2';
568         $parentcontextparams = array();
569         $parentcontextids = get_parent_contexts($context);
570         if ($parentcontextids) {
571             list($parentcontexttest, $parentcontextparams) =
572                     $DB->get_in_or_equal($parentcontextids, SQL_PARAMS_NAMED, 'parentcontext');
573             $contexttest = "($contexttest OR (bi.showinsubcontexts = 1 AND bi.parentcontextid $parentcontexttest))";
574         }
576         $pagetypepatterns = matching_page_type_patterns($this->page->pagetype);
577         list($pagetypepatterntest, $pagetypepatternparams) =
578                 $DB->get_in_or_equal($pagetypepatterns, SQL_PARAMS_NAMED, 'pagetypepatterntest');
580         list($ccselect, $ccjoin) = context_instance_preload_sql('bi.id', CONTEXT_BLOCK, 'ctx');
582         $params = array(
583             'subpage1' => $this->page->subpage,
584             'subpage2' => $this->page->subpage,
585             'contextid1' => $context->id,
586             'contextid2' => $context->id,
587             'pagetype' => $this->page->pagetype,
588         );
589         if ($this->page->subpage === '') {
590             $params['subpage1'] = $DB->sql_empty();
591             $params['subpage2'] = $DB->sql_empty();
592         }
593         $sql = "SELECT
594                     bi.id,
595                     bp.id AS blockpositionid,
596                     bi.blockname,
597                     bi.parentcontextid,
598                     bi.showinsubcontexts,
599                     bi.pagetypepattern,
600                     bi.subpagepattern,
601                     bi.defaultregion,
602                     bi.defaultweight,
603                     COALESCE(bp.visible, 1) AS visible,
604                     COALESCE(bp.region, bi.defaultregion) AS region,
605                     COALESCE(bp.weight, bi.defaultweight) AS weight,
606                     bi.configdata
607                     $ccselect
609                 FROM {block_instances} bi
610                 JOIN {block} b ON bi.blockname = b.name
611                 LEFT JOIN {block_positions} bp ON bp.blockinstanceid = bi.id
612                                                   AND bp.contextid = :contextid1
613                                                   AND bp.pagetype = :pagetype
614                                                   AND bp.subpage = :subpage1
615                 $ccjoin
617                 WHERE
618                 $contexttest
619                 AND bi.pagetypepattern $pagetypepatterntest
620                 AND (bi.subpagepattern IS NULL OR bi.subpagepattern = :subpage2)
621                 $visiblecheck
622                 AND b.visible = 1
624                 ORDER BY
625                     COALESCE(bp.region, bi.defaultregion),
626                     COALESCE(bp.weight, bi.defaultweight),
627                     bi.id";
628         $blockinstances = $DB->get_recordset_sql($sql, $params + $parentcontextparams + $pagetypepatternparams);
630         $this->birecordsbyregion = $this->prepare_per_region_arrays();
631         $unknown = array();
632         foreach ($blockinstances as $bi) {
633             context_instance_preload($bi);
634             if ($this->is_known_region($bi->region)) {
635                 $this->birecordsbyregion[$bi->region][] = $bi;
636             } else {
637                 $unknown[] = $bi;
638             }
639         }
641         // Pages don't necessarily have a defaultregion. The  one time this can
642         // happen is when there are no theme block regions, but the script itself
643         // has a block region in the main content area.
644         if (!empty($this->defaultregion)) {
645             $this->birecordsbyregion[$this->defaultregion] =
646                     array_merge($this->birecordsbyregion[$this->defaultregion], $unknown);
647         }
648     }
650     /**
651      * Add a block to the current page, or related pages. The block is added to
652      * context $this->page->contextid. If $pagetypepattern $subpagepattern
653      *
654      * @param string $blockname The type of block to add.
655      * @param string $region the block region on this page to add the block to.
656      * @param integer $weight determines the order where this block appears in the region.
657      * @param boolean $showinsubcontexts whether this block appears in subcontexts, or just the current context.
658      * @param string|null $pagetypepattern which page types this block should appear on. Defaults to just the current page type.
659      * @param string|null $subpagepattern which subpage this block should appear on. NULL = any (the default), otherwise only the specified subpage.
660      */
661     public function add_block($blockname, $region, $weight, $showinsubcontexts, $pagetypepattern = NULL, $subpagepattern = NULL) {
662         global $DB;
663         // Allow invisible blocks because this is used when adding default page blocks, which
664         // might include invisible ones if the user makes some default blocks invisible
665         $this->check_known_block_type($blockname, true);
666         $this->check_region_is_known($region);
668         if (empty($pagetypepattern)) {
669             $pagetypepattern = $this->page->pagetype;
670         }
672         $blockinstance = new stdClass;
673         $blockinstance->blockname = $blockname;
674         $blockinstance->parentcontextid = $this->page->context->id;
675         $blockinstance->showinsubcontexts = !empty($showinsubcontexts);
676         $blockinstance->pagetypepattern = $pagetypepattern;
677         $blockinstance->subpagepattern = $subpagepattern;
678         $blockinstance->defaultregion = $region;
679         $blockinstance->defaultweight = $weight;
680         $blockinstance->configdata = '';
681         $blockinstance->id = $DB->insert_record('block_instances', $blockinstance);
683         // Ensure the block context is created.
684         context_block::instance($blockinstance->id);
686         // If the new instance was created, allow it to do additional setup
687         if ($block = block_instance($blockname, $blockinstance)) {
688             $block->instance_create();
689         }
690     }
692     public function add_block_at_end_of_default_region($blockname) {
693         $defaulregion = $this->get_default_region();
695         $lastcurrentblock = end($this->birecordsbyregion[$defaulregion]);
696         if ($lastcurrentblock) {
697             $weight = $lastcurrentblock->weight + 1;
698         } else {
699             $weight = 0;
700         }
702         if ($this->page->subpage) {
703             $subpage = $this->page->subpage;
704         } else {
705             $subpage = null;
706         }
708         // Special case. Course view page type include the course format, but we
709         // want to add the block non-format-specifically.
710         $pagetypepattern = $this->page->pagetype;
711         if (strpos($pagetypepattern, 'course-view') === 0) {
712             $pagetypepattern = 'course-view-*';
713         }
715         // We should end using this for ALL the blocks, making always the 1st option
716         // the default one to be used. Until then, this is one hack to avoid the
717         // 'pagetypewarning' message on blocks initial edition (MDL-27829) caused by
718         // non-existing $pagetypepattern set. This way at least we guarantee one "valid"
719         // (the FIRST $pagetypepattern will be set)
721         // We are applying it to all blocks created in mod pages for now and only if the
722         // default pagetype is not one of the available options
723         if (preg_match('/^mod-.*-/', $pagetypepattern)) {
724             $pagetypelist = generate_page_type_patterns($this->page->pagetype, null, $this->page->context);
725             // Only go for the first if the pagetype is not a valid option
726             if (is_array($pagetypelist) && !array_key_exists($pagetypepattern, $pagetypelist)) {
727                 $pagetypepattern = key($pagetypelist);
728             }
729         }
730         // Surely other pages like course-report will need this too, they just are not important
731         // enough now. This will be decided in the coming days. (MDL-27829, MDL-28150)
733         $this->add_block($blockname, $defaulregion, $weight, false, $pagetypepattern, $subpage);
734     }
736     /**
737      * Convenience method, calls add_block repeatedly for all the blocks in $blocks.
738      *
739      * @param array $blocks array with array keys the region names, and values an array of block names.
740      * @param string $pagetypepattern optional. Passed to @see add_block()
741      * @param string $subpagepattern optional. Passed to @see add_block()
742      */
743     public function add_blocks($blocks, $pagetypepattern = NULL, $subpagepattern = NULL, $showinsubcontexts=false, $weight=0) {
744         $this->add_regions(array_keys($blocks));
745         foreach ($blocks as $region => $regionblocks) {
746             $weight = 0;
747             foreach ($regionblocks as $blockname) {
748                 $this->add_block($blockname, $region, $weight, $showinsubcontexts, $pagetypepattern, $subpagepattern);
749                 $weight += 1;
750             }
751         }
752     }
754     /**
755      * Move a block to a new position on this page.
756      *
757      * If this block cannot appear on any other pages, then we change defaultposition/weight
758      * in the block_instances table. Otherwise we just set the position on this page.
759      *
760      * @param $blockinstanceid the block instance id.
761      * @param $newregion the new region name.
762      * @param $newweight the new weight.
763      */
764     public function reposition_block($blockinstanceid, $newregion, $newweight) {
765         global $DB;
767         $this->check_region_is_known($newregion);
768         $inst = $this->find_instance($blockinstanceid);
770         $bi = $inst->instance;
771         if ($bi->weight == $bi->defaultweight && $bi->region == $bi->defaultregion &&
772                 !$bi->showinsubcontexts && strpos($bi->pagetypepattern, '*') === false &&
773                 (!$this->page->subpage || $bi->subpagepattern)) {
775             // Set default position
776             $newbi = new stdClass;
777             $newbi->id = $bi->id;
778             $newbi->defaultregion = $newregion;
779             $newbi->defaultweight = $newweight;
780             $DB->update_record('block_instances', $newbi);
782             if ($bi->blockpositionid) {
783                 $bp = new stdClass;
784                 $bp->id = $bi->blockpositionid;
785                 $bp->region = $newregion;
786                 $bp->weight = $newweight;
787                 $DB->update_record('block_positions', $bp);
788             }
790         } else {
791             // Just set position on this page.
792             $bp = new stdClass;
793             $bp->region = $newregion;
794             $bp->weight = $newweight;
796             if ($bi->blockpositionid) {
797                 $bp->id = $bi->blockpositionid;
798                 $DB->update_record('block_positions', $bp);
800             } else {
801                 $bp->blockinstanceid = $bi->id;
802                 $bp->contextid = $this->page->context->id;
803                 $bp->pagetype = $this->page->pagetype;
804                 if ($this->page->subpage) {
805                     $bp->subpage = $this->page->subpage;
806                 } else {
807                     $bp->subpage = '';
808                 }
809                 $bp->visible = $bi->visible;
810                 $DB->insert_record('block_positions', $bp);
811             }
812         }
813     }
815     /**
816      * Find a given block by its instance id
817      *
818      * @param integer $instanceid
819      * @return block_base
820      */
821     public function find_instance($instanceid) {
822         foreach ($this->regions as $region => $notused) {
823             $this->ensure_instances_exist($region);
824             foreach($this->blockinstances[$region] as $instance) {
825                 if ($instance->instance->id == $instanceid) {
826                     return $instance;
827                 }
828             }
829         }
830         throw new block_not_on_page_exception($instanceid, $this->page);
831     }
833 /// Inner workings =============================================================
835     /**
836      * Check whether the page blocks have been loaded yet
837      *
838      * @return void Throws coding exception if already loaded
839      */
840     protected function check_not_yet_loaded() {
841         if (!is_null($this->birecordsbyregion)) {
842             throw new coding_exception('block_manager has already loaded the blocks, to it is too late to change things that might affect which blocks are visible.');
843         }
844     }
846     /**
847      * Check whether the page blocks have been loaded yet
848      *
849      * Nearly identical to the above function {@link check_not_yet_loaded()} except different message
850      *
851      * @return void Throws coding exception if already loaded
852      */
853     protected function check_is_loaded() {
854         if (is_null($this->birecordsbyregion)) {
855             throw new coding_exception('block_manager has not yet loaded the blocks, to it is too soon to request the information you asked for.');
856         }
857     }
859     /**
860      * Check if a block type is known and usable
861      *
862      * @param string $blockname The block type name to search for
863      * @param bool $includeinvisible Include disabled block types in the initial pass
864      * @return void Coding Exception thrown if unknown or not enabled
865      */
866     protected function check_known_block_type($blockname, $includeinvisible = false) {
867         if (!$this->is_known_block_type($blockname, $includeinvisible)) {
868             if ($this->is_known_block_type($blockname, true)) {
869                 throw new coding_exception('Unknown block type ' . $blockname);
870             } else {
871                 throw new coding_exception('Block type ' . $blockname . ' has been disabled by the administrator.');
872             }
873         }
874     }
876     /**
877      * Check if a region is known by its name
878      *
879      * @param string $region
880      * @return void Coding Exception thrown if the region is not known
881      */
882     protected function check_region_is_known($region) {
883         if (!$this->is_known_region($region)) {
884             throw new coding_exception('Trying to reference an unknown block region ' . $region);
885         }
886     }
888     /**
889      * Returns an array of region names as keys and nested arrays for values
890      *
891      * @return array an array where the array keys are the region names, and the array
892      * values are empty arrays.
893      */
894     protected function prepare_per_region_arrays() {
895         $result = array();
896         foreach ($this->regions as $region => $notused) {
897             $result[$region] = array();
898         }
899         return $result;
900     }
902     /**
903      * Create a set of new block instance from a record array
904      *
905      * @param array $birecords An array of block instance records
906      * @return array An array of instantiated block_instance objects
907      */
908     protected function create_block_instances($birecords) {
909         $results = array();
910         foreach ($birecords as $record) {
911             if ($blockobject = block_instance($record->blockname, $record, $this->page)) {
912                 $results[] = $blockobject;
913             }
914         }
915         return $results;
916     }
918     /**
919      * Create all the block instances for all the blocks that were loaded by
920      * load_blocks. This is used, for example, to ensure that all blocks get a
921      * chance to initialise themselves via the {@link block_base::specialize()}
922      * method, before any output is done.
923      */
924     public function create_all_block_instances() {
925         foreach ($this->get_regions() as $region) {
926             $this->ensure_instances_exist($region);
927         }
928     }
930     /**
931      * Return an array of content objects from a set of block instances
932      *
933      * @param array $instances An array of block instances
934      * @param renderer_base The renderer to use.
935      * @param string $region the region name.
936      * @return array An array of block_content (and possibly block_move_target) objects.
937      */
938     protected function create_block_contents($instances, $output, $region) {
939         $results = array();
941         $lastweight = 0;
942         $lastblock = 0;
943         if ($this->movingblock) {
944             $first = reset($instances);
945             if ($first) {
946                 $lastweight = $first->instance->weight - 2;
947             }
949             $strmoveblockhere = get_string('moveblockhere', 'block');
950         }
952         foreach ($instances as $instance) {
953             $content = $instance->get_content_for_output($output);
954             if (empty($content)) {
955                 continue;
956             }
958             if ($this->movingblock && $lastweight != $instance->instance->weight &&
959                     $content->blockinstanceid != $this->movingblock && $lastblock != $this->movingblock) {
960                 $results[] = new block_move_target($strmoveblockhere, $this->get_move_target_url($region, ($lastweight + $instance->instance->weight)/2));
961             }
963             if ($content->blockinstanceid == $this->movingblock) {
964                 $content->add_class('beingmoved');
965                 $content->annotation .= get_string('movingthisblockcancel', 'block',
966                         html_writer::link($this->page->url, get_string('cancel')));
967             }
969             $results[] = $content;
970             $lastweight = $instance->instance->weight;
971             $lastblock = $instance->instance->id;
972         }
974         if ($this->movingblock && $lastblock != $this->movingblock) {
975             $results[] = new block_move_target($strmoveblockhere, $this->get_move_target_url($region, $lastweight + 1));
976         }
977         return $results;
978     }
980     /**
981      * Ensure block instances exist for a given region
982      *
983      * @param string $region Check for bi's with the instance with this name
984      */
985     protected function ensure_instances_exist($region) {
986         $this->check_region_is_known($region);
987         if (!array_key_exists($region, $this->blockinstances)) {
988             $this->blockinstances[$region] =
989                     $this->create_block_instances($this->birecordsbyregion[$region]);
990         }
991     }
993     /**
994      * Ensure that there is some content within the given region
995      *
996      * @param string $region The name of the region to check
997      */
998     protected function ensure_content_created($region, $output) {
999         $this->ensure_instances_exist($region);
1000         if (!array_key_exists($region, $this->visibleblockcontent)) {
1001             $contents = array();
1002             if (array_key_exists($region, $this->extracontent)) {
1003                 $contents = $this->extracontent[$region];
1004             }
1005             $contents = array_merge($contents, $this->create_block_contents($this->blockinstances[$region], $output, $region));
1006             if ($region == $this->defaultregion) {
1007                 $addblockui = block_add_block_ui($this->page, $output);
1008                 if ($addblockui) {
1009                     $contents[] = $addblockui;
1010                 }
1011             }
1012             $this->visibleblockcontent[$region] = $contents;
1013         }
1014     }
1016 /// Process actions from the URL ===============================================
1018     /**
1019      * Get the appropriate list of editing icons for a block. This is used
1020      * to set {@link block_contents::$controls} in {@link block_base::get_contents_for_output()}.
1021      *
1022      * @param $output The core_renderer to use when generating the output. (Need to get icon paths.)
1023      * @return an array in the format for {@link block_contents::$controls}
1024      */
1025     public function edit_controls($block) {
1026         global $CFG;
1028         $controls = array();
1029         $actionurl = $this->page->url->out(false, array('sesskey'=> sesskey()));
1031         if ($this->page->user_can_edit_blocks()) {
1032             // Move icon.
1033             $controls[] = array('url' => $actionurl . '&bui_moveid=' . $block->instance->id,
1034                     'icon' => 't/move', 'caption' => get_string('move'), 'class' => 'editing_move');
1035         }
1037         if ($this->page->user_can_edit_blocks() || $block->user_can_edit()) {
1038             // Edit config icon - always show - needed for positioning UI.
1039             $controls[] = array('url' => $actionurl . '&bui_editid=' . $block->instance->id,
1040                     'icon' => 't/edit', 'caption' => get_string('configuration'), 'class' => 'editing_edit');
1041         }
1043         if ($this->user_can_delete_block($block)) {
1044             // Delete icon.
1045             $controls[] = array('url' => $actionurl . '&bui_deleteid=' . $block->instance->id,
1046                     'icon' => 't/delete', 'caption' => get_string('delete'), 'class' => 'editing_delete');
1047         }
1049         if ($this->page->user_can_edit_blocks() && $block->instance_can_be_hidden()) {
1050             // Show/hide icon.
1051             if ($block->instance->visible) {
1052                 $controls[] = array('url' => $actionurl . '&bui_hideid=' . $block->instance->id,
1053                         'icon' => 't/hide', 'caption' => get_string('hide'), 'class' => 'editing_hide');
1054             } else {
1055                 $controls[] = array('url' => $actionurl . '&bui_showid=' . $block->instance->id,
1056                         'icon' => 't/show', 'caption' => get_string('show'), 'class' => 'editing_show');
1057             }
1058         }
1060         // Assign roles icon.
1061         if (has_capability('moodle/role:assign', $block->context)) {
1062             //TODO: please note it is sloppy to pass urls through page parameters!!
1063             //      it is shortened because some web servers (e.g. IIS by default) give
1064             //      a 'security' error if you try to pass a full URL as a GET parameter in another URL.
1065             $return = $this->page->url->out(false);
1066             $return = str_replace($CFG->wwwroot . '/', '', $return);
1068             $controls[] = array('url' => $CFG->wwwroot . '/' . $CFG->admin .
1069                     '/roles/assign.php?contextid=' . $block->context->id . '&returnurl=' . urlencode($return),
1070                     'icon' => 't/assignroles', 'caption' => get_string('assignroles', 'role'), 'class' => 'editing_roles');
1071         }
1073         return $controls;
1074     }
1076     /**
1077      * @param block_base $block a block that appears on this page.
1078      * @return boolean boolean whether the currently logged in user is allowed to delete this block.
1079      */
1080     protected function user_can_delete_block($block) {
1081         return $this->page->user_can_edit_blocks() && $block->user_can_edit() &&
1082                 $block->user_can_addto($this->page) &&
1083                 !in_array($block->instance->blockname, self::get_undeletable_block_types());
1084     }
1086     /**
1087      * Process any block actions that were specified in the URL.
1088      *
1089      * @return boolean true if anything was done. False if not.
1090      */
1091     public function process_url_actions() {
1092         if (!$this->page->user_is_editing()) {
1093             return false;
1094         }
1095         return $this->process_url_add() || $this->process_url_delete() ||
1096             $this->process_url_show_hide() || $this->process_url_edit() ||
1097             $this->process_url_move();
1098     }
1100     /**
1101      * Handle adding a block.
1102      * @return boolean true if anything was done. False if not.
1103      */
1104     public function process_url_add() {
1105         $blocktype = optional_param('bui_addblock', null, PARAM_PLUGIN);
1106         if (!$blocktype) {
1107             return false;
1108         }
1110         require_sesskey();
1112         if (!$this->page->user_can_edit_blocks()) {
1113             throw new moodle_exception('nopermissions', '', $this->page->url->out(), get_string('addblock'));
1114         }
1116         if (!array_key_exists($blocktype, $this->get_addable_blocks())) {
1117             throw new moodle_exception('cannotaddthisblocktype', '', $this->page->url->out(), $blocktype);
1118         }
1120         $this->add_block_at_end_of_default_region($blocktype);
1122         // If the page URL was a guess, it will contain the bui_... param, so we must make sure it is not there.
1123         $this->page->ensure_param_not_in_url('bui_addblock');
1125         return true;
1126     }
1128     /**
1129      * Handle deleting a block.
1130      * @return boolean true if anything was done. False if not.
1131      */
1132     public function process_url_delete() {
1133         global $CFG, $PAGE, $OUTPUT;
1135         $blockid = optional_param('bui_deleteid', null, PARAM_INT);
1136         $confirmdelete = optional_param('bui_confirm', null, PARAM_INT);
1138         if (!$blockid) {
1139             return false;
1140         }
1142         require_sesskey();
1143         $block = $this->page->blocks->find_instance($blockid);
1144         if (!$this->user_can_delete_block($block)) {
1145             throw new moodle_exception('nopermissions', '', $this->page->url->out(), get_string('deleteablock'));
1146         }
1148         if (!$confirmdelete) {
1149             $deletepage = new moodle_page();
1150             $deletepage->set_pagelayout('admin');
1151             $deletepage->set_course($this->page->course);
1152             $deletepage->set_context($this->page->context);
1153             if ($this->page->cm) {
1154                 $deletepage->set_cm($this->page->cm);
1155             }
1157             $deleteurlbase = str_replace($CFG->wwwroot . '/', '/', $this->page->url->out_omit_querystring());
1158             $deleteurlparams = $this->page->url->params();
1159             $deletepage->set_url($deleteurlbase, $deleteurlparams);
1160             $deletepage->set_block_actions_done();
1161             // At this point we are either going to redirect, or display the form, so
1162             // overwrite global $PAGE ready for this. (Formslib refers to it.)
1163             $PAGE = $deletepage;
1164             //some functions like MoodleQuickForm::addHelpButton use $OUTPUT so we need to replace that too
1165             $output = $deletepage->get_renderer('core');
1166             $OUTPUT = $output;
1168             $site = get_site();
1169             $blocktitle = $block->get_title();
1170             $strdeletecheck = get_string('deletecheck', 'block', $blocktitle);
1171             $message = get_string('deleteblockcheck', 'block', $blocktitle);
1173             $PAGE->navbar->add($strdeletecheck);
1174             $PAGE->set_title($blocktitle . ': ' . $strdeletecheck);
1175             $PAGE->set_heading($site->fullname);
1176             echo $OUTPUT->header();
1177             $confirmurl = new moodle_url($deletepage->url, array('sesskey' => sesskey(), 'bui_deleteid' => $block->instance->id, 'bui_confirm' => 1));
1178             $cancelurl = new moodle_url($deletepage->url);
1179             $yesbutton = new single_button($confirmurl, get_string('yes'));
1180             $nobutton = new single_button($cancelurl, get_string('no'));
1181             echo $OUTPUT->confirm($message, $yesbutton, $nobutton);
1182             echo $OUTPUT->footer();
1183             // Make sure that nothing else happens after we have displayed this form.
1184             exit;
1185         } else {
1186             blocks_delete_instance($block->instance);
1187             // bui_deleteid and bui_confirm should not be in the PAGE url.
1188             $this->page->ensure_param_not_in_url('bui_deleteid');
1189             $this->page->ensure_param_not_in_url('bui_confirm');
1190             return true;
1191         }
1192     }
1194     /**
1195      * Handle showing or hiding a block.
1196      * @return boolean true if anything was done. False if not.
1197      */
1198     public function process_url_show_hide() {
1199         if ($blockid = optional_param('bui_hideid', null, PARAM_INT)) {
1200             $newvisibility = 0;
1201         } else if ($blockid = optional_param('bui_showid', null, PARAM_INT)) {
1202             $newvisibility = 1;
1203         } else {
1204             return false;
1205         }
1207         require_sesskey();
1209         $block = $this->page->blocks->find_instance($blockid);
1211         if (!$this->page->user_can_edit_blocks()) {
1212             throw new moodle_exception('nopermissions', '', $this->page->url->out(), get_string('hideshowblocks'));
1213         } else if (!$block->instance_can_be_hidden()) {
1214             return false;
1215         }
1217         blocks_set_visibility($block->instance, $this->page, $newvisibility);
1219         // If the page URL was a guses, it will contain the bui_... param, so we must make sure it is not there.
1220         $this->page->ensure_param_not_in_url('bui_hideid');
1221         $this->page->ensure_param_not_in_url('bui_showid');
1223         return true;
1224     }
1226     /**
1227      * Handle showing/processing the submission from the block editing form.
1228      * @return boolean true if the form was submitted and the new config saved. Does not
1229      *      return if the editing form was displayed. False otherwise.
1230      */
1231     public function process_url_edit() {
1232         global $CFG, $DB, $PAGE, $OUTPUT;
1234         $blockid = optional_param('bui_editid', null, PARAM_INT);
1235         if (!$blockid) {
1236             return false;
1237         }
1239         require_sesskey();
1240         require_once($CFG->dirroot . '/blocks/edit_form.php');
1242         $block = $this->find_instance($blockid);
1244         if (!$block->user_can_edit() && !$this->page->user_can_edit_blocks()) {
1245             throw new moodle_exception('nopermissions', '', $this->page->url->out(), get_string('editblock'));
1246         }
1248         $editpage = new moodle_page();
1249         $editpage->set_pagelayout('admin');
1250         $editpage->set_course($this->page->course);
1251         //$editpage->set_context($block->context);
1252         $editpage->set_context($this->page->context);
1253         if ($this->page->cm) {
1254             $editpage->set_cm($this->page->cm);
1255         }
1256         $editurlbase = str_replace($CFG->wwwroot . '/', '/', $this->page->url->out_omit_querystring());
1257         $editurlparams = $this->page->url->params();
1258         $editurlparams['bui_editid'] = $blockid;
1259         $editpage->set_url($editurlbase, $editurlparams);
1260         $editpage->set_block_actions_done();
1261         // At this point we are either going to redirect, or display the form, so
1262         // overwrite global $PAGE ready for this. (Formslib refers to it.)
1263         $PAGE = $editpage;
1264         //some functions like MoodleQuickForm::addHelpButton use $OUTPUT so we need to replace that to
1265         $output = $editpage->get_renderer('core');
1266         $OUTPUT = $output;
1268         $formfile = $CFG->dirroot . '/blocks/' . $block->name() . '/edit_form.php';
1269         if (is_readable($formfile)) {
1270             require_once($formfile);
1271             $classname = 'block_' . $block->name() . '_edit_form';
1272             if (!class_exists($classname)) {
1273                 $classname = 'block_edit_form';
1274             }
1275         } else {
1276             $classname = 'block_edit_form';
1277         }
1279         $mform = new $classname($editpage->url, $block, $this->page);
1280         $mform->set_data($block->instance);
1282         if ($mform->is_cancelled()) {
1283             redirect($this->page->url);
1285         } else if ($data = $mform->get_data()) {
1286             $bi = new stdClass;
1287             $bi->id = $block->instance->id;
1288             $bi->pagetypepattern = $data->bui_pagetypepattern;
1289             if (empty($data->bui_subpagepattern) || $data->bui_subpagepattern == '%@NULL@%') {
1290                 $bi->subpagepattern = null;
1291             } else {
1292                 $bi->subpagepattern = $data->bui_subpagepattern;
1293             }
1295             $systemcontext = context_system::instance();
1296             $frontpagecontext = context_course::instance(SITEID);
1297             $parentcontext = context::instance_by_id($data->bui_parentcontextid);
1299             // Updating stickiness and contexts.  See MDL-21375 for details.
1300             if (has_capability('moodle/site:manageblocks', $parentcontext)) { // Check permissions in destination
1302                 // Explicitly set the default context
1303                 $bi->parentcontextid = $parentcontext->id;
1305                 if ($data->bui_editingatfrontpage) {   // The block is being edited on the front page
1307                     // The interface here is a special case because the pagetype pattern is
1308                     // totally derived from the context menu.  Here are the excpetions.   MDL-30340
1310                     switch ($data->bui_contexts) {
1311                         case BUI_CONTEXTS_ENTIRE_SITE:
1312                             // The user wants to show the block across the entire site
1313                             $bi->parentcontextid = $systemcontext->id;
1314                             $bi->showinsubcontexts = true;
1315                             $bi->pagetypepattern  = '*';
1316                             break;
1317                         case BUI_CONTEXTS_FRONTPAGE_SUBS:
1318                             // The user wants the block shown on the front page and all subcontexts
1319                             $bi->parentcontextid = $frontpagecontext->id;
1320                             $bi->showinsubcontexts = true;
1321                             $bi->pagetypepattern  = '*';
1322                             break;
1323                         case BUI_CONTEXTS_FRONTPAGE_ONLY:
1324                             // The user want to show the front page on the frontpage only
1325                             $bi->parentcontextid = $frontpagecontext->id;
1326                             $bi->showinsubcontexts = false;
1327                             $bi->pagetypepattern  = 'site-index';
1328                             // This is the only relevant page type anyway but we'll set it explicitly just
1329                             // in case the front page grows site-index-* subpages of its own later
1330                             break;
1331                     }
1332                 }
1333             }
1335             $bits = explode('-', $bi->pagetypepattern);
1336             // hacks for some contexts
1337             if (($parentcontext->contextlevel == CONTEXT_COURSE) && ($parentcontext->instanceid != SITEID)) {
1338                 // For course context
1339                 // is page type pattern is mod-*, change showinsubcontext to 1
1340                 if ($bits[0] == 'mod' || $bi->pagetypepattern == '*') {
1341                     $bi->showinsubcontexts = 1;
1342                 } else {
1343                     $bi->showinsubcontexts = 0;
1344                 }
1345             } else  if ($parentcontext->contextlevel == CONTEXT_USER) {
1346                 // for user context
1347                 // subpagepattern should be null
1348                 if ($bits[0] == 'user' or $bits[0] == 'my') {
1349                     // we don't need subpagepattern in usercontext
1350                     $bi->subpagepattern = null;
1351                 }
1352             }
1354             $bi->defaultregion = $data->bui_defaultregion;
1355             $bi->defaultweight = $data->bui_defaultweight;
1356             $DB->update_record('block_instances', $bi);
1358             if (!empty($block->config)) {
1359                 $config = clone($block->config);
1360             } else {
1361                 $config = new stdClass;
1362             }
1363             foreach ($data as $configfield => $value) {
1364                 if (strpos($configfield, 'config_') !== 0) {
1365                     continue;
1366                 }
1367                 $field = substr($configfield, 7);
1368                 $config->$field = $value;
1369             }
1370             $block->instance_config_save($config);
1372             $bp = new stdClass;
1373             $bp->visible = $data->bui_visible;
1374             $bp->region = $data->bui_region;
1375             $bp->weight = $data->bui_weight;
1376             $needbprecord = !$data->bui_visible || $data->bui_region != $data->bui_defaultregion ||
1377                     $data->bui_weight != $data->bui_defaultweight;
1379             if ($block->instance->blockpositionid && !$needbprecord) {
1380                 $DB->delete_records('block_positions', array('id' => $block->instance->blockpositionid));
1382             } else if ($block->instance->blockpositionid && $needbprecord) {
1383                 $bp->id = $block->instance->blockpositionid;
1384                 $DB->update_record('block_positions', $bp);
1386             } else if ($needbprecord) {
1387                 $bp->blockinstanceid = $block->instance->id;
1388                 $bp->contextid = $this->page->context->id;
1389                 $bp->pagetype = $this->page->pagetype;
1390                 if ($this->page->subpage) {
1391                     $bp->subpage = $this->page->subpage;
1392                 } else {
1393                     $bp->subpage = '';
1394                 }
1395                 $DB->insert_record('block_positions', $bp);
1396             }
1398             redirect($this->page->url);
1400         } else {
1401             $strheading = get_string('blockconfiga', 'moodle', $block->get_title());
1402             $editpage->set_title($strheading);
1403             $editpage->set_heading($strheading);
1404             $bits = explode('-', $this->page->pagetype);
1405             if ($bits[0] == 'tag' && !empty($this->page->subpage)) {
1406                 // better navbar for tag pages
1407                 $editpage->navbar->add(get_string('tags'), new moodle_url('/tag/'));
1408                 $tag = tag_get('id', $this->page->subpage, '*');
1409                 // tag search page doesn't have subpageid
1410                 if ($tag) {
1411                     $editpage->navbar->add($tag->name, new moodle_url('/tag/index.php', array('id'=>$tag->id)));
1412                 }
1413             }
1414             $editpage->navbar->add($block->get_title());
1415             $editpage->navbar->add(get_string('configuration'));
1416             echo $output->header();
1417             echo $output->heading($strheading, 2);
1418             $mform->display();
1419             echo $output->footer();
1420             exit;
1421         }
1422     }
1424     /**
1425      * Handle showing/processing the submission from the block editing form.
1426      * @return boolean true if the form was submitted and the new config saved. Does not
1427      *      return if the editing form was displayed. False otherwise.
1428      */
1429     public function process_url_move() {
1430         global $CFG, $DB, $PAGE;
1432         $blockid = optional_param('bui_moveid', null, PARAM_INT);
1433         if (!$blockid) {
1434             return false;
1435         }
1437         require_sesskey();
1439         $block = $this->find_instance($blockid);
1441         if (!$this->page->user_can_edit_blocks()) {
1442             throw new moodle_exception('nopermissions', '', $this->page->url->out(), get_string('editblock'));
1443         }
1445         $newregion = optional_param('bui_newregion', '', PARAM_ALPHANUMEXT);
1446         $newweight = optional_param('bui_newweight', null, PARAM_FLOAT);
1447         if (!$newregion || is_null($newweight)) {
1448             // Don't have a valid target position yet, must be just starting the move.
1449             $this->movingblock = $blockid;
1450             $this->page->ensure_param_not_in_url('bui_moveid');
1451             return false;
1452         }
1454         if (!$this->is_known_region($newregion)) {
1455             throw new moodle_exception('unknownblockregion', '', $this->page->url, $newregion);
1456         }
1458         // Move this block. This may involve moving other nearby blocks.
1459         $blocks = $this->birecordsbyregion[$newregion];
1461         $maxweight = self::MAX_WEIGHT;
1462         $minweight = -self::MAX_WEIGHT;
1464         // Initialise the used weights and spareweights array with the default values
1465         $spareweights = array();
1466         $usedweights = array();
1467         for ($i = $minweight; $i <= $maxweight; $i++) {
1468             $spareweights[$i] = $i;
1469             $usedweights[$i] = array();
1470         }
1472         // Check each block and sort out where we have used weights
1473         foreach ($blocks as $bi) {
1474             if ($bi->weight > $maxweight) {
1475                 // If this statement is true then the blocks weight is more than the
1476                 // current maximum. To ensure that we can get the best block position
1477                 // we will initialise elements within the usedweights and spareweights
1478                 // arrays between the blocks weight (which will then be the new max) and
1479                 // the current max
1480                 $parseweight = $bi->weight;
1481                 while (!array_key_exists($parseweight, $usedweights)) {
1482                     $usedweights[$parseweight] = array();
1483                     $spareweights[$parseweight] = $parseweight;
1484                     $parseweight--;
1485                 }
1486                 $maxweight = $bi->weight;
1487             } else if ($bi->weight < $minweight) {
1488                 // As above except this time the blocks weight is LESS than the
1489                 // the current minimum, so we will initialise the array from the
1490                 // blocks weight (new minimum) to the current minimum
1491                 $parseweight = $bi->weight;
1492                 while (!array_key_exists($parseweight, $usedweights)) {
1493                     $usedweights[$parseweight] = array();
1494                     $spareweights[$parseweight] = $parseweight;
1495                     $parseweight++;
1496                 }
1497                 $minweight = $bi->weight;
1498             }
1499             if ($bi->id != $block->instance->id) {
1500                 unset($spareweights[$bi->weight]);
1501                 $usedweights[$bi->weight][] = $bi->id;
1502             }
1503         }
1505         // First we find the nearest gap in the list of weights.
1506         $bestdistance = max(abs($newweight - self::MAX_WEIGHT), abs($newweight + self::MAX_WEIGHT)) + 1;
1507         $bestgap = null;
1508         foreach ($spareweights as $spareweight) {
1509             if (abs($newweight - $spareweight) < $bestdistance) {
1510                 $bestdistance = abs($newweight - $spareweight);
1511                 $bestgap = $spareweight;
1512             }
1513         }
1515         // If there is no gap, we have to go outside -self::MAX_WEIGHT .. self::MAX_WEIGHT.
1516         if (is_null($bestgap)) {
1517             $bestgap = self::MAX_WEIGHT + 1;
1518             while (!empty($usedweights[$bestgap])) {
1519                 $bestgap++;
1520             }
1521         }
1523         // Now we know the gap we are aiming for, so move all the blocks along.
1524         if ($bestgap < $newweight) {
1525             $newweight = floor($newweight);
1526             for ($weight = $bestgap + 1; $weight <= $newweight; $weight++) {
1527                 foreach ($usedweights[$weight] as $biid) {
1528                     $this->reposition_block($biid, $newregion, $weight - 1);
1529                 }
1530             }
1531             $this->reposition_block($block->instance->id, $newregion, $newweight);
1532         } else {
1533             $newweight = ceil($newweight);
1534             for ($weight = $bestgap - 1; $weight >= $newweight; $weight--) {
1535                 if (array_key_exists($weight, $usedweights)) {
1536                     foreach ($usedweights[$weight] as $biid) {
1537                         $this->reposition_block($biid, $newregion, $weight + 1);
1538                     }
1539                 }
1540             }
1541             $this->reposition_block($block->instance->id, $newregion, $newweight);
1542         }
1544         $this->page->ensure_param_not_in_url('bui_moveid');
1545         $this->page->ensure_param_not_in_url('bui_newregion');
1546         $this->page->ensure_param_not_in_url('bui_newweight');
1547         return true;
1548     }
1550     /**
1551      * Turns the display of normal blocks either on or off.
1552      *
1553      * @param bool $setting
1554      */
1555     public function show_only_fake_blocks($setting = true) {
1556         $this->fakeblocksonly = $setting;
1557     }
1560 /// Helper functions for working with block classes ============================
1562 /**
1563  * Call a class method (one that does not require a block instance) on a block class.
1564  *
1565  * @param string $blockname the name of the block.
1566  * @param string $method the method name.
1567  * @param array $param parameters to pass to the method.
1568  * @return mixed whatever the method returns.
1569  */
1570 function block_method_result($blockname, $method, $param = NULL) {
1571     if(!block_load_class($blockname)) {
1572         return NULL;
1573     }
1574     return call_user_func(array('block_'.$blockname, $method), $param);
1577 /**
1578  * Creates a new instance of the specified block class.
1579  *
1580  * @param string $blockname the name of the block.
1581  * @param $instance block_instances DB table row (optional).
1582  * @param moodle_page $page the page this block is appearing on.
1583  * @return block_base the requested block instance.
1584  */
1585 function block_instance($blockname, $instance = NULL, $page = NULL) {
1586     if(!block_load_class($blockname)) {
1587         return false;
1588     }
1589     $classname = 'block_'.$blockname;
1590     $retval = new $classname;
1591     if($instance !== NULL) {
1592         if (is_null($page)) {
1593             global $PAGE;
1594             $page = $PAGE;
1595         }
1596         $retval->_load_instance($instance, $page);
1597     }
1598     return $retval;
1601 /**
1602  * Load the block class for a particular type of block.
1603  *
1604  * @param string $blockname the name of the block.
1605  * @return boolean success or failure.
1606  */
1607 function block_load_class($blockname) {
1608     global $CFG;
1610     if(empty($blockname)) {
1611         return false;
1612     }
1614     $classname = 'block_'.$blockname;
1616     if(class_exists($classname)) {
1617         return true;
1618     }
1620     $blockpath = $CFG->dirroot.'/blocks/'.$blockname.'/block_'.$blockname.'.php';
1622     if (file_exists($blockpath)) {
1623         require_once($CFG->dirroot.'/blocks/moodleblock.class.php');
1624         include_once($blockpath);
1625     }else{
1626         //debugging("$blockname code does not exist in $blockpath", DEBUG_DEVELOPER);
1627         return false;
1628     }
1630     return class_exists($classname);
1633 /**
1634  * Given a specific page type, return all the page type patterns that might
1635  * match it.
1636  *
1637  * @param string $pagetype for example 'course-view-weeks' or 'mod-quiz-view'.
1638  * @return array an array of all the page type patterns that might match this page type.
1639  */
1640 function matching_page_type_patterns($pagetype) {
1641     $patterns = array($pagetype);
1642     $bits = explode('-', $pagetype);
1643     if (count($bits) == 3 && $bits[0] == 'mod') {
1644         if ($bits[2] == 'view') {
1645             $patterns[] = 'mod-*-view';
1646         } else if ($bits[2] == 'index') {
1647             $patterns[] = 'mod-*-index';
1648         }
1649     }
1650     while (count($bits) > 0) {
1651         $patterns[] = implode('-', $bits) . '-*';
1652         array_pop($bits);
1653     }
1654     $patterns[] = '*';
1655     return $patterns;
1658 /**
1659  * Given a specific page type, parent context and currect context, return all the page type patterns
1660  * that might be used by this block.
1661  *
1662  * @param string $pagetype for example 'course-view-weeks' or 'mod-quiz-view'.
1663  * @param stdClass $parentcontext Block's parent context
1664  * @param stdClass $currentcontext Current context of block
1665  * @return array an array of all the page type patterns that might match this page type.
1666  */
1667 function generate_page_type_patterns($pagetype, $parentcontext = null, $currentcontext = null) {
1668     global $CFG;
1670     $bits = explode('-', $pagetype);
1672     $core = get_core_subsystems();
1673     $plugins = get_plugin_types();
1675     //progressively strip pieces off the page type looking for a match
1676     $componentarray = null;
1677     for ($i = count($bits); $i > 0; $i--) {
1678         $possiblecomponentarray = array_slice($bits, 0, $i);
1679         $possiblecomponent = implode('', $possiblecomponentarray);
1681         // Check to see if the component is a core component
1682         if (array_key_exists($possiblecomponent, $core) && !empty($core[$possiblecomponent])) {
1683             $libfile = $CFG->dirroot.'/'.$core[$possiblecomponent].'/lib.php';
1684             if (file_exists($libfile)) {
1685                 require_once($libfile);
1686                 $function = $possiblecomponent.'_page_type_list';
1687                 if (function_exists($function)) {
1688                     if ($patterns = $function($pagetype, $parentcontext, $currentcontext)) {
1689                         break;
1690                     }
1691                 }
1692             }
1693         }
1695         //check the plugin directory and look for a callback
1696         if (array_key_exists($possiblecomponent, $plugins) && !empty($plugins[$possiblecomponent])) {
1698             //We've found a plugin type. Look for a plugin name by getting the next section of page type
1699             if (count($bits) > $i) {
1700                 $pluginname = $bits[$i];
1701                 $directory = get_plugin_directory($possiblecomponent, $pluginname);
1702                 if (!empty($directory)){
1703                     $libfile = $directory.'/lib.php';
1704                     if (file_exists($libfile)) {
1705                         require_once($libfile);
1706                         $function = $possiblecomponent.'_'.$pluginname.'_page_type_list';
1707                         if (!function_exists($function)) {
1708                             $function = $pluginname.'_page_type_list';
1709                         }
1710                         if (function_exists($function)) {
1711                             if ($patterns = $function($pagetype, $parentcontext, $currentcontext)) {
1712                                 break;
1713                             }
1714                         }
1715                     }
1716                 }
1717             }
1719             //we'll only get to here if we still don't have any patterns
1720             //the plugin type may have a callback
1721             $directory = get_plugin_directory($possiblecomponent, null);
1722             if (!empty($directory)){
1723                 $libfile = $directory.'/lib.php';
1724                 if (file_exists($libfile)) {
1725                     require_once($libfile);
1726                     $function = $possiblecomponent.'_page_type_list';
1727                     if (function_exists($function)) {
1728                         if ($patterns = $function($pagetype, $parentcontext, $currentcontext)) {
1729                             break;
1730                         }
1731                     }
1732                 }
1733             }
1734         }
1735     }
1737     if (empty($patterns)) {
1738         $patterns = default_page_type_list($pagetype, $parentcontext, $currentcontext);
1739     }
1741     // Ensure that the * pattern is always available if editing block 'at distance', so
1742     // we always can 'bring back' it to the original context. MDL-30340
1743     if ((!isset($currentcontext) or !isset($parentcontext) or $currentcontext->id != $parentcontext->id) && !isset($patterns['*'])) {
1744         // TODO: We could change the string here, showing its 'bring back' meaning
1745         $patterns['*'] = get_string('page-x', 'pagetype');
1746     }
1748     return $patterns;
1751 /**
1752  * Generates a default page type list when a more appropriate callback cannot be decided upon.
1753  *
1754  * @param string $pagetype
1755  * @param stdClass $parentcontext
1756  * @param stdClass $currentcontext
1757  * @return array
1758  */
1759 function default_page_type_list($pagetype, $parentcontext = null, $currentcontext = null) {
1760     // Generate page type patterns based on current page type if
1761     // callbacks haven't been defined
1762     $patterns = array($pagetype => $pagetype);
1763     $bits = explode('-', $pagetype);
1764     while (count($bits) > 0) {
1765         $pattern = implode('-', $bits) . '-*';
1766         $pagetypestringname = 'page-'.str_replace('*', 'x', $pattern);
1767         // guessing page type description
1768         if (get_string_manager()->string_exists($pagetypestringname, 'pagetype')) {
1769             $patterns[$pattern] = get_string($pagetypestringname, 'pagetype');
1770         } else {
1771             $patterns[$pattern] = $pattern;
1772         }
1773         array_pop($bits);
1774     }
1775     $patterns['*'] = get_string('page-x', 'pagetype');
1776     return $patterns;
1779 /**
1780  * Generates the page type list for the my moodle page
1781  *
1782  * @param string $pagetype
1783  * @param stdClass $parentcontext
1784  * @param stdClass $currentcontext
1785  * @return array
1786  */
1787 function my_page_type_list($pagetype, $parentcontext = null, $currentcontext = null) {
1788     return array('my-index' => get_string('page-my-index', 'pagetype'));
1791 /**
1792  * Generates the page type list for a module by either locating and using the modules callback
1793  * or by generating a default list.
1794  *
1795  * @param string $pagetype
1796  * @param stdClass $parentcontext
1797  * @param stdClass $currentcontext
1798  * @return array
1799  */
1800 function mod_page_type_list($pagetype, $parentcontext = null, $currentcontext = null) {
1801     $patterns = plugin_page_type_list($pagetype, $parentcontext, $currentcontext);
1802     if (empty($patterns)) {
1803         // if modules don't have callbacks
1804         // generate two default page type patterns for modules only
1805         $bits = explode('-', $pagetype);
1806         $patterns = array($pagetype => $pagetype);
1807         if ($bits[2] == 'view') {
1808             $patterns['mod-*-view'] = get_string('page-mod-x-view', 'pagetype');
1809         } else if ($bits[2] == 'index') {
1810             $patterns['mod-*-index'] = get_string('page-mod-x-index', 'pagetype');
1811         }
1812     }
1813     return $patterns;
1815 /// Functions update the blocks if required by the request parameters ==========
1817 /**
1818  * Return a {@link block_contents} representing the add a new block UI, if
1819  * this user is allowed to see it.
1820  *
1821  * @return block_contents an appropriate block_contents, or null if the user
1822  * cannot add any blocks here.
1823  */
1824 function block_add_block_ui($page, $output) {
1825     global $CFG, $OUTPUT;
1826     if (!$page->user_is_editing() || !$page->user_can_edit_blocks()) {
1827         return null;
1828     }
1830     $bc = new block_contents();
1831     $bc->title = get_string('addblock');
1832     $bc->add_class('block_adminblock');
1834     $missingblocks = $page->blocks->get_addable_blocks();
1835     if (empty($missingblocks)) {
1836         $bc->content = get_string('noblockstoaddhere');
1837         return $bc;
1838     }
1840     $menu = array();
1841     foreach ($missingblocks as $block) {
1842         $blockobject = block_instance($block->name);
1843         if ($blockobject !== false && $blockobject->user_can_addto($page)) {
1844             $menu[$block->name] = $blockobject->get_title();
1845         }
1846     }
1847     collatorlib::asort($menu);
1849     $actionurl = new moodle_url($page->url, array('sesskey'=>sesskey()));
1850     $select = new single_select($actionurl, 'bui_addblock', $menu, null, array(''=>get_string('adddots')), 'add_block');
1851     $bc->content = $OUTPUT->render($select);
1852     return $bc;
1855 // Functions that have been deprecated by block_manager =======================
1857 /**
1858  * @deprecated since Moodle 2.0 - use $page->blocks->get_addable_blocks();
1859  *
1860  * This function returns an array with the IDs of any blocks that you can add to your page.
1861  * Parameters are passed by reference for speed; they are not modified at all.
1862  *
1863  * @param $page the page object.
1864  * @param $blockmanager Not used.
1865  * @return array of block type ids.
1866  */
1867 function blocks_get_missing(&$page, &$blockmanager) {
1868     debugging('blocks_get_missing is deprecated. Please use $page->blocks->get_addable_blocks() instead.', DEBUG_DEVELOPER);
1869     $blocks = $page->blocks->get_addable_blocks();
1870     $ids = array();
1871     foreach ($blocks as $block) {
1872         $ids[] = $block->id;
1873     }
1874     return $ids;
1877 /**
1878  * Actually delete from the database any blocks that are currently on this page,
1879  * but which should not be there according to blocks_name_allowed_in_format.
1880  *
1881  * @todo Write/Fix this function. Currently returns immediately
1882  * @param $course
1883  */
1884 function blocks_remove_inappropriate($course) {
1885     // TODO
1886     return;
1887     /*
1888     $blockmanager = blocks_get_by_page($page);
1890     if (empty($blockmanager)) {
1891         return;
1892     }
1894     if (($pageformat = $page->pagetype) == NULL) {
1895         return;
1896     }
1898     foreach($blockmanager as $region) {
1899         foreach($region as $instance) {
1900             $block = blocks_get_record($instance->blockid);
1901             if(!blocks_name_allowed_in_format($block->name, $pageformat)) {
1902                blocks_delete_instance($instance->instance);
1903             }
1904         }
1905     }*/
1908 /**
1909  * Check that a given name is in a permittable format
1910  *
1911  * @param string $name
1912  * @param string $pageformat
1913  * @return bool
1914  */
1915 function blocks_name_allowed_in_format($name, $pageformat) {
1916     $accept = NULL;
1917     $maxdepth = -1;
1918     if (!$bi = block_instance($name)) {
1919         return false;
1920     }
1922     $formats = $bi->applicable_formats();
1923     if (!$formats) {
1924         $formats = array();
1925     }
1926     foreach ($formats as $format => $allowed) {
1927         $formatregex = '/^'.str_replace('*', '[^-]*', $format).'.*$/';
1928         $depth = substr_count($format, '-');
1929         if (preg_match($formatregex, $pageformat) && $depth > $maxdepth) {
1930             $maxdepth = $depth;
1931             $accept = $allowed;
1932         }
1933     }
1934     if ($accept === NULL) {
1935         $accept = !empty($formats['all']);
1936     }
1937     return $accept;
1940 /**
1941  * Delete a block, and associated data.
1942  *
1943  * @param object $instance a row from the block_instances table
1944  * @param bool $nolongerused legacy parameter. Not used, but kept for backwards compatibility.
1945  * @param bool $skipblockstables for internal use only. Makes @see blocks_delete_all_for_context() more efficient.
1946  */
1947 function blocks_delete_instance($instance, $nolongerused = false, $skipblockstables = false) {
1948     global $DB;
1950     if ($block = block_instance($instance->blockname, $instance)) {
1951         $block->instance_delete();
1952     }
1953     delete_context(CONTEXT_BLOCK, $instance->id);
1955     if (!$skipblockstables) {
1956         $DB->delete_records('block_positions', array('blockinstanceid' => $instance->id));
1957         $DB->delete_records('block_instances', array('id' => $instance->id));
1958         $DB->delete_records_list('user_preferences', 'name', array('block'.$instance->id.'hidden','docked_block_instance_'.$instance->id));
1959     }
1962 /**
1963  * Delete all the blocks that belong to a particular context.
1964  *
1965  * @param int $contextid the context id.
1966  */
1967 function blocks_delete_all_for_context($contextid) {
1968     global $DB;
1969     $instances = $DB->get_recordset('block_instances', array('parentcontextid' => $contextid));
1970     foreach ($instances as $instance) {
1971         blocks_delete_instance($instance, true);
1972     }
1973     $instances->close();
1974     $DB->delete_records('block_instances', array('parentcontextid' => $contextid));
1975     $DB->delete_records('block_positions', array('contextid' => $contextid));
1978 /**
1979  * Set a block to be visible or hidden on a particular page.
1980  *
1981  * @param object $instance a row from the block_instances, preferably LEFT JOINed with the
1982  *      block_positions table as return by block_manager.
1983  * @param moodle_page $page the back to set the visibility with respect to.
1984  * @param integer $newvisibility 1 for visible, 0 for hidden.
1985  */
1986 function blocks_set_visibility($instance, $page, $newvisibility) {
1987     global $DB;
1988     if (!empty($instance->blockpositionid)) {
1989         // Already have local information on this page.
1990         $DB->set_field('block_positions', 'visible', $newvisibility, array('id' => $instance->blockpositionid));
1991         return;
1992     }
1994     // Create a new block_positions record.
1995     $bp = new stdClass;
1996     $bp->blockinstanceid = $instance->id;
1997     $bp->contextid = $page->context->id;
1998     $bp->pagetype = $page->pagetype;
1999     if ($page->subpage) {
2000         $bp->subpage = $page->subpage;
2001     }
2002     $bp->visible = $newvisibility;
2003     $bp->region = $instance->defaultregion;
2004     $bp->weight = $instance->defaultweight;
2005     $DB->insert_record('block_positions', $bp);
2008 /**
2009  * @deprecated since 2.0
2010  * Delete all the blocks from a particular page.
2011  *
2012  * @param string $pagetype the page type.
2013  * @param integer $pageid the page id.
2014  * @return bool success or failure.
2015  */
2016 function blocks_delete_all_on_page($pagetype, $pageid) {
2017     global $DB;
2019     debugging('Call to deprecated function blocks_delete_all_on_page. ' .
2020             'This function cannot work any more. Doing nothing. ' .
2021             'Please update your code to use a block_manager method $PAGE->blocks->....', DEBUG_DEVELOPER);
2022     return false;
2025 /**
2026  * Get the block record for a particular blockid - that is, a particular type os block.
2027  *
2028  * @param $int blockid block type id. If null, an array of all block types is returned.
2029  * @param bool $notusedanymore No longer used.
2030  * @return array|object row from block table, or all rows.
2031  */
2032 function blocks_get_record($blockid = NULL, $notusedanymore = false) {
2033     global $PAGE;
2034     $blocks = $PAGE->blocks->get_installed_blocks();
2035     if ($blockid === NULL) {
2036         return $blocks;
2037     } else if (isset($blocks[$blockid])) {
2038         return $blocks[$blockid];
2039     } else {
2040         return false;
2041     }
2044 /**
2045  * Find a given block by its blockid within a provide array
2046  *
2047  * @param int $blockid
2048  * @param array $blocksarray
2049  * @return bool|object Instance if found else false
2050  */
2051 function blocks_find_block($blockid, $blocksarray) {
2052     if (empty($blocksarray)) {
2053         return false;
2054     }
2055     foreach($blocksarray as $blockgroup) {
2056         if (empty($blockgroup)) {
2057             continue;
2058         }
2059         foreach($blockgroup as $instance) {
2060             if($instance->blockid == $blockid) {
2061                 return $instance;
2062             }
2063         }
2064     }
2065     return false;
2068 // Functions for programatically adding default blocks to pages ================
2070 /**
2071  * Parse a list of default blocks. See config-dist for a description of the format.
2072  *
2073  * @param string $blocksstr
2074  * @return array
2075  */
2076 function blocks_parse_default_blocks_list($blocksstr) {
2077     $blocks = array();
2078     $bits = explode(':', $blocksstr);
2079     if (!empty($bits)) {
2080         $leftbits = trim(array_shift($bits));
2081         if ($leftbits != '') {
2082             $blocks[BLOCK_POS_LEFT] = explode(',', $leftbits);
2083         }
2084     }
2085     if (!empty($bits)) {
2086         $rightbits =trim(array_shift($bits));
2087         if ($rightbits != '') {
2088             $blocks[BLOCK_POS_RIGHT] = explode(',', $rightbits);
2089         }
2090     }
2091     return $blocks;
2094 /**
2095  * @return array the blocks that should be added to the site course by default.
2096  */
2097 function blocks_get_default_site_course_blocks() {
2098     global $CFG;
2100     if (!empty($CFG->defaultblocks_site)) {
2101         return blocks_parse_default_blocks_list($CFG->defaultblocks_site);
2102     } else {
2103         return array(
2104             BLOCK_POS_LEFT => array('site_main_menu'),
2105             BLOCK_POS_RIGHT => array('course_summary', 'calendar_month')
2106         );
2107     }
2110 /**
2111  * Add the default blocks to a course.
2112  *
2113  * @param object $course a course object.
2114  */
2115 function blocks_add_default_course_blocks($course) {
2116     global $CFG;
2118     if (!empty($CFG->defaultblocks_override)) {
2119         $blocknames = blocks_parse_default_blocks_list($CFG->defaultblocks_override);
2121     } else if ($course->id == SITEID) {
2122         $blocknames = blocks_get_default_site_course_blocks();
2124     } else if (!empty($CFG->{'defaultblocks_' . $course->format})) {
2125         $blocknames = blocks_parse_default_blocks_list($CFG->{'defaultblocks_' . $course->format});
2127     } else {
2128         $blocknames = course_get_format($course)->get_default_blocks();
2130     }
2132     if ($course->id == SITEID) {
2133         $pagetypepattern = 'site-index';
2134     } else {
2135         $pagetypepattern = 'course-view-*';
2136     }
2137     $page = new moodle_page();
2138     $page->set_course($course);
2139     $page->blocks->add_blocks($blocknames, $pagetypepattern);
2142 /**
2143  * Add the default system-context blocks. E.g. the admin tree.
2144  */
2145 function blocks_add_default_system_blocks() {
2146     global $DB;
2148     $page = new moodle_page();
2149     $page->set_context(context_system::instance());
2150     $page->blocks->add_blocks(array(BLOCK_POS_LEFT => array('navigation', 'settings')), '*', null, true);
2151     $page->blocks->add_blocks(array(BLOCK_POS_LEFT => array('admin_bookmarks')), 'admin-*', null, null, 2);
2153     if ($defaultmypage = $DB->get_record('my_pages', array('userid'=>null, 'name'=>'__default', 'private'=>1))) {
2154         $subpagepattern = $defaultmypage->id;
2155     } else {
2156         $subpagepattern = null;
2157     }
2159     $page->blocks->add_blocks(array(BLOCK_POS_RIGHT => array('private_files', 'online_users'), 'content' => array('course_overview')), 'my-index', $subpagepattern, false);