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 * Block Class and Functions
21 * This file defines the {@link block_manager} class,
25 * @copyright 1999 onwards Martin Dougiamas http://dougiamas.com
26 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
29 defined('MOODLE_INTERNAL') ||
die();
32 * Default names for the block regions in the standard theme.
34 define('BLOCK_POS_LEFT', 'side-pre');
35 define('BLOCK_POS_RIGHT', 'side-post');
38 define('BUI_CONTEXTS_FRONTPAGE_ONLY', 0);
39 define('BUI_CONTEXTS_FRONTPAGE_SUBS', 1);
40 define('BUI_CONTEXTS_ENTIRE_SITE', 2);
42 define('BUI_CONTEXTS_CURRENT', 0);
43 define('BUI_CONTEXTS_CURRENT_SUBS', 1);
45 // Position of "Add block" control, to be used in theme config as a value for $THEME->addblockposition:
46 // - default: as a fake block that is displayed in editing mode
47 // - flatnav: "Add block" item in the flat navigation drawer in editing mode
48 // - custom: none of the above, theme will take care of displaying the control.
49 define('BLOCK_ADDBLOCK_POSITION_DEFAULT', 0);
50 define('BLOCK_ADDBLOCK_POSITION_FLATNAV', 1);
51 define('BLOCK_ADDBLOCK_POSITION_CUSTOM', -1);
54 * Exception thrown when someone tried to do something with a block that does
55 * not exist on a page.
57 * @copyright 2009 Tim Hunt
58 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
61 class block_not_on_page_exception
extends moodle_exception
{
64 * @param int $instanceid the block instance id of the block that was looked for.
65 * @param object $page the current page.
67 public function __construct($instanceid, $page) {
69 $a->instanceid
= $instanceid;
70 $a->url
= $page->url
->out();
71 parent
::__construct('blockdoesnotexistonpage', '', $page->url
->out(), $a);
76 * This class keeps track of the block that should appear on a moodle_page.
78 * The page to work with as passed to the constructor.
80 * @copyright 2009 Tim Hunt
81 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
86 * The UI normally only shows block weights between -MAX_WEIGHT and MAX_WEIGHT,
87 * although other weights are valid.
89 const MAX_WEIGHT
= 10;
91 /// Field declarations =========================================================
94 * the moodle_page we are managing blocks for.
99 /** @var array region name => 1.*/
100 protected $regions = array();
102 /** @var string the region where new blocks are added.*/
103 protected $defaultregion = null;
105 /** @var array will be $DB->get_records('blocks') */
106 protected $allblocks = null;
109 * @var array blocks that this user can add to this page. Will be a subset
110 * of $allblocks, but with array keys block->name. Access this via the
111 * {@link get_addable_blocks()} method to ensure it is lazy-loaded.
113 protected $addableblocks = null;
116 * Will be an array region-name => array(db rows loaded in load_blocks);
119 protected $birecordsbyregion = null;
122 * array region-name => array(block objects); populated as necessary by
123 * the ensure_instances_exist method.
126 protected $blockinstances = array();
129 * array region-name => array(block_contents objects) what actually needs to
130 * be displayed in each region.
133 protected $visibleblockcontent = array();
136 * array region-name => array(block_contents objects) extra block-like things
137 * to be displayed in each region, before the real blocks.
140 protected $extracontent = array();
143 * Used by the block move id, to track whether a block is currently being moved.
145 * When you click on the move icon of a block, first the page needs to reload with
146 * extra UI for choosing a new position for a particular block. In that situation
147 * this field holds the id of the block being moved.
151 protected $movingblock = null;
154 * Show only fake blocks
156 protected $fakeblocksonly = false;
158 /// Constructor ================================================================
162 * @param object $page the moodle_page object object we are managing the blocks for,
163 * or a reasonable faxilimily. (See the comment at the top of this class
164 * and {@link http://en.wikipedia.org/wiki/Duck_typing})
166 public function __construct($page) {
170 /// Getter methods =============================================================
173 * Get an array of all region names on this page where a block may appear
175 * @return array the internal names of the regions on this page where block may appear.
177 public function get_regions() {
178 if (is_null($this->defaultregion
)) {
179 $this->page
->initialise_theme_and_output();
181 return array_keys($this->regions
);
185 * Get the region name of the region blocks are added to by default
187 * @return string the internal names of the region where new blocks are added
188 * by default, and where any blocks from an unrecognised region are shown.
189 * (Imagine that blocks were added with one theme selected, then you switched
190 * to a theme with different block positions.)
192 public function get_default_region() {
193 $this->page
->initialise_theme_and_output();
194 return $this->defaultregion
;
198 * The list of block types that may be added to this page.
200 * @return array block name => record from block table.
202 public function get_addable_blocks() {
203 $this->check_is_loaded();
205 if (!is_null($this->addableblocks
)) {
206 return $this->addableblocks
;
210 $this->addableblocks
= array();
212 $allblocks = blocks_get_record();
213 if (empty($allblocks)) {
214 return $this->addableblocks
;
217 $unaddableblocks = self
::get_undeletable_block_types();
218 $requiredbythemeblocks = $this->get_required_by_theme_block_types();
219 $pageformat = $this->page
->pagetype
;
220 foreach($allblocks as $block) {
221 if (!$bi = block_instance($block->name
)) {
224 if ($block->visible
&& !in_array($block->name
, $unaddableblocks) &&
225 !in_array($block->name
, $requiredbythemeblocks) &&
226 ($bi->instance_allow_multiple() ||
!$this->is_block_present($block->name
)) &&
227 blocks_name_allowed_in_format($block->name
, $pageformat) &&
228 $bi->user_can_addto($this->page
)) {
229 $block->title
= $bi->get_title();
230 $this->addableblocks
[$block->name
] = $block;
234 core_collator
::asort_objects_by_property($this->addableblocks
, 'title');
235 return $this->addableblocks
;
239 * Given a block name, find out of any of them are currently present in the page
241 * @param string $blockname - the basic name of a block (eg "navigation")
242 * @return boolean - is there one of these blocks in the current page?
244 public function is_block_present($blockname) {
245 if (empty($this->blockinstances
)) {
249 $requiredbythemeblocks = $this->get_required_by_theme_block_types();
250 foreach ($this->blockinstances
as $region) {
251 foreach ($region as $instance) {
252 if (empty($instance->instance
->blockname
)) {
255 if ($instance->instance
->blockname
== $blockname) {
256 if ($instance->instance
->requiredbytheme
) {
257 if (!in_array($blockname, $requiredbythemeblocks)) {
269 * Find out if a block type is known by the system
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.
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
)) {
286 * Find out if a region exists on a page
288 * @param string $region a region name
289 * @return boolean true if this region exists on this page.
291 public function is_known_region($region) {
292 if (empty($region)) {
295 return array_key_exists($region, $this->regions
);
299 * Get an array of all blocks within a given region
301 * @param string $region a block region that exists on this page.
302 * @return array of block instances.
304 public function get_blocks_for_region($region) {
305 $this->check_is_loaded();
306 $this->ensure_instances_exist($region);
307 return $this->blockinstances
[$region];
311 * Returns an array of block content objects that exist in a region
313 * @param string $region a block region that exists on this page.
314 * @return array of block block_contents objects for all the blocks in a region.
316 public function get_content_for_region($region, $output) {
317 $this->check_is_loaded();
318 $this->ensure_content_created($region, $output);
319 return $this->visibleblockcontent
[$region];
323 * Returns an array of block content objects for all the existings regions
325 * @param renderer_base $output the rendered to use
326 * @return array of block block_contents objects for all the blocks in all regions.
329 public function get_content_for_all_regions($output) {
331 $this->check_is_loaded();
333 foreach ($this->regions
as $region => $val) {
334 $this->ensure_content_created($region, $output);
335 $contents[$region] = $this->visibleblockcontent
[$region];
341 * Helper method used by get_content_for_region.
342 * @param string $region region name
343 * @param float $weight weight. May be fractional, since you may want to move a block
344 * between ones with weight 2 and 3, say ($weight would be 2.5).
345 * @return string URL for moving block $this->movingblock to this position.
347 protected function get_move_target_url($region, $weight) {
348 return new moodle_url($this->page
->url
, array('bui_moveid' => $this->movingblock
,
349 'bui_newregion' => $region, 'bui_newweight' => $weight, 'sesskey' => sesskey()));
353 * Determine whether a region contains anything. (Either any real blocks, or
354 * the add new block UI.)
356 * (You may wonder why the $output parameter is required. Unfortunately,
357 * because of the way that blocks work, the only reliable way to find out
358 * if a block will be visible is to get the content for output, and to
359 * get the content, you need a renderer. Fortunately, this is not a
360 * performance problem, because we cache the output that is generated, and
361 * in almost every case where we call region_has_content, we are about to
362 * output the blocks anyway, so we are not doing wasted effort.)
364 * @param string $region a block region that exists on this page.
365 * @param core_renderer $output a core_renderer. normally the global $OUTPUT.
366 * @return boolean Whether there is anything in this region.
368 public function region_has_content($region, $output) {
370 if (!$this->is_known_region($region)) {
373 $this->check_is_loaded();
374 $this->ensure_content_created($region, $output);
375 // if ($this->page->user_is_editing() && $this->page->user_can_edit_blocks()) {
376 // Mark Nielsen's patch - part 1
377 if ($this->page
->user_is_editing() && $this->page
->user_can_edit_blocks() && $this->movingblock
) {
378 // If editing is on, we need all the block regions visible, for the
382 return !empty($this->visibleblockcontent
[$region]) ||
!empty($this->extracontent
[$region]);
386 * Get an array of all of the installed blocks.
388 * @return array contents of the block table.
390 public function get_installed_blocks() {
392 if (is_null($this->allblocks
)) {
393 $this->allblocks
= $DB->get_records('block');
395 return $this->allblocks
;
399 * @return array names of block types that must exist on every page with this theme.
401 public function get_required_by_theme_block_types() {
402 $requiredbythemeblocks = false;
403 if (isset($this->page
->theme
->requiredblocks
)) {
404 $requiredbythemeblocks = $this->page
->theme
->requiredblocks
;
407 if ($requiredbythemeblocks === false) {
408 return array('navigation', 'settings');
409 } else if ($requiredbythemeblocks === '') {
411 } else if (is_string($requiredbythemeblocks)) {
412 return explode(',', $requiredbythemeblocks);
414 return $requiredbythemeblocks;
419 * Make this block type undeletable and unaddable.
421 * @param mixed $blockidorname string or int
423 public static function protect_block($blockidorname) {
426 $syscontext = context_system
::instance();
428 require_capability('moodle/site:config', $syscontext);
431 if (is_int($blockidorname)) {
432 $block = $DB->get_record('block', array('id' => $blockidorname), 'id, name', MUST_EXIST
);
434 $block = $DB->get_record('block', array('name' => $blockidorname), 'id, name', MUST_EXIST
);
436 $undeletableblocktypes = self
::get_undeletable_block_types();
437 if (!in_array($block->name
, $undeletableblocktypes)) {
438 $undeletableblocktypes[] = $block->name
;
439 set_config('undeletableblocktypes', implode(',', $undeletableblocktypes));
440 add_to_config_log('block_protect', "0", "1", $block->name
);
445 * Make this block type deletable and addable.
447 * @param mixed $blockidorname string or int
449 public static function unprotect_block($blockidorname) {
452 $syscontext = context_system
::instance();
454 require_capability('moodle/site:config', $syscontext);
457 if (is_int($blockidorname)) {
458 $block = $DB->get_record('block', array('id' => $blockidorname), 'id, name', MUST_EXIST
);
460 $block = $DB->get_record('block', array('name' => $blockidorname), 'id, name', MUST_EXIST
);
462 $undeletableblocktypes = self
::get_undeletable_block_types();
463 if (in_array($block->name
, $undeletableblocktypes)) {
464 $undeletableblocktypes = array_diff($undeletableblocktypes, array($block->name
));
465 set_config('undeletableblocktypes', implode(',', $undeletableblocktypes));
466 add_to_config_log('block_protect', "1", "0", $block->name
);
472 * Get the list of "protected" blocks via admin block manager ui.
474 * @return array names of block types that cannot be added or deleted. E.g. array('navigation','settings').
476 public static function get_undeletable_block_types() {
478 $undeletableblocks = false;
479 if (isset($CFG->undeletableblocktypes
)) {
480 $undeletableblocks = $CFG->undeletableblocktypes
;
483 if (empty($undeletableblocks)) {
485 } else if (is_string($undeletableblocks)) {
486 return explode(',', $undeletableblocks);
488 return $undeletableblocks;
492 /// Setter methods =============================================================
495 * Add a region to a page
497 * @param string $region add a named region where blocks may appear on the current page.
498 * This is an internal name, like 'side-pre', not a string to display in the UI.
499 * @param bool $custom True if this is a custom block region, being added by the page rather than the theme layout.
501 public function add_region($region, $custom = true) {
503 $this->check_not_yet_loaded();
505 if (array_key_exists($region, $this->regions
)) {
506 // This here is EXACTLY why we should not be adding block regions into a page. It should
507 // ALWAYS be done in a theme layout.
508 debugging('A custom region conflicts with a block region in the theme.', DEBUG_DEVELOPER
);
510 // We need to register this custom region against the page type being used.
511 // This allows us to check, when performing block actions, that unrecognised regions can be worked with.
512 $type = $this->page
->pagetype
;
513 if (!isset($SESSION->custom_block_regions
)) {
514 $SESSION->custom_block_regions
= array($type => array($region));
515 } else if (!isset($SESSION->custom_block_regions
[$type])) {
516 $SESSION->custom_block_regions
[$type] = array($region);
517 } else if (!in_array($region, $SESSION->custom_block_regions
[$type])) {
518 $SESSION->custom_block_regions
[$type][] = $region;
521 $this->regions
[$region] = 1;
525 * Add an array of regions
528 * @param array $regions this utility method calls add_region for each array element.
530 public function add_regions($regions, $custom = true) {
531 foreach ($regions as $region) {
532 $this->add_region($region, $custom);
537 * Finds custom block regions associated with a page type and registers them with this block manager.
539 * @param string $pagetype
541 public function add_custom_regions_for_pagetype($pagetype) {
543 if (isset($SESSION->custom_block_regions
[$pagetype])) {
544 foreach ($SESSION->custom_block_regions
[$pagetype] as $customregion) {
545 $this->add_region($customregion, false);
551 * Set the default region for new blocks on the page
553 * @param string $defaultregion the internal names of the region where new
554 * blocks should be added by default, and where any blocks from an
555 * unrecognised region are shown.
557 public function set_default_region($defaultregion) {
558 $this->check_not_yet_loaded();
559 if ($defaultregion) {
560 $this->check_region_is_known($defaultregion);
562 $this->defaultregion
= $defaultregion;
566 * Add something that looks like a block, but which isn't an actual block_instance,
569 * @param block_contents $bc the content of the block-like thing.
570 * @param string $region a block region that exists on this page.
572 public function add_fake_block($bc, $region) {
573 $this->page
->initialise_theme_and_output();
574 if (!$this->is_known_region($region)) {
575 $region = $this->get_default_region();
577 if (array_key_exists($region, $this->visibleblockcontent
)) {
578 throw new coding_exception('block_manager has already prepared the blocks in region ' .
579 $region . 'for output. It is too late to add a fake block.');
581 if (!isset($bc->attributes
['data-block'])) {
582 $bc->attributes
['data-block'] = '_fake';
584 $bc->attributes
['class'] .= ' block_fake';
585 $this->extracontent
[$region][] = $bc;
589 * Checks to see whether all of the blocks within the given region are docked
591 * @see region_uses_dock
592 * @param string $region
593 * @return bool True if all of the blocks within that region are docked
595 public function region_completely_docked($region, $output) {
597 // If theme doesn't allow docking or allowblockstodock is not set, then return.
598 if (!$this->page
->theme
->enable_dock ||
empty($CFG->allowblockstodock
)) {
602 // Do not dock the region when the user attemps to move a block.
603 if ($this->movingblock
) {
607 // Block regions should not be docked during editing when all the blocks are hidden.
608 if ($this->page
->user_is_editing() && $this->page
->user_can_edit_blocks()) {
612 $this->check_is_loaded();
613 $this->ensure_content_created($region, $output);
614 if (!$this->region_has_content($region, $output)) {
615 // If the region has no content then nothing is docked at all of course.
618 foreach ($this->visibleblockcontent
[$region] as $instance) {
619 if (!get_user_preferences('docked_block_instance_'.$instance->blockinstanceid
, 0)) {
627 * Checks to see whether any of the blocks within the given regions are docked
629 * @see region_completely_docked
630 * @param array|string $regions array of regions (or single region)
631 * @return bool True if any of the blocks within that region are docked
633 public function region_uses_dock($regions, $output) {
634 if (!$this->page
->theme
->enable_dock
) {
637 $this->check_is_loaded();
638 foreach((array)$regions as $region) {
639 $this->ensure_content_created($region, $output);
640 foreach($this->visibleblockcontent
[$region] as $instance) {
641 if(!empty($instance->content
) && get_user_preferences('docked_block_instance_'.$instance->blockinstanceid
, 0)) {
649 /// Actions ====================================================================
652 * This method actually loads the blocks for our page from the database.
654 * @param boolean|null $includeinvisible
655 * null (default) - load hidden blocks if $this->page->user_is_editing();
656 * true - load hidden blocks.
657 * false - don't load hidden blocks.
659 public function load_blocks($includeinvisible = null) {
662 if (!is_null($this->birecordsbyregion
)) {
667 if ($CFG->version
< 2009050619) {
668 // Upgrade/install not complete. Don't try too show any blocks.
669 $this->birecordsbyregion
= array();
673 // Ensure we have been initialised.
674 if (is_null($this->defaultregion
)) {
675 $this->page
->initialise_theme_and_output();
676 // If there are still no block regions, then there are no blocks on this page.
677 if (empty($this->regions
)) {
678 $this->birecordsbyregion
= array();
683 // Check if we need to load normal blocks
684 if ($this->fakeblocksonly
) {
685 $this->birecordsbyregion
= $this->prepare_per_region_arrays();
689 // Exclude auto created blocks if they are not undeletable in this theme.
690 $requiredbytheme = $this->get_required_by_theme_block_types();
691 $requiredbythemecheck = '';
692 $requiredbythemeparams = array();
693 $requiredbythemenotparams = array();
694 if (!empty($requiredbytheme)) {
695 list($testsql, $requiredbythemeparams) = $DB->get_in_or_equal($requiredbytheme, SQL_PARAMS_NAMED
, 'requiredbytheme');
696 list($testnotsql, $requiredbythemenotparams) = $DB->get_in_or_equal($requiredbytheme, SQL_PARAMS_NAMED
,
697 'notrequiredbytheme', false);
698 $requiredbythemecheck = 'AND ((bi.blockname ' . $testsql . ' AND bi.requiredbytheme = 1) OR ' .
699 ' (bi.blockname ' . $testnotsql . ' AND bi.requiredbytheme = 0))';
701 $requiredbythemecheck = 'AND (bi.requiredbytheme = 0)';
704 if (is_null($includeinvisible)) {
705 $includeinvisible = $this->page
->user_is_editing();
707 if ($includeinvisible) {
710 $visiblecheck = 'AND (bp.visible = 1 OR bp.visible IS NULL) AND (bs.visible = 1 OR bs.visible IS NULL)';
713 $context = $this->page
->context
;
714 $contexttest = 'bi.parentcontextid IN (:contextid2, :contextid3)';
715 $parentcontextparams = array();
716 $parentcontextids = $context->get_parent_context_ids();
717 if ($parentcontextids) {
718 list($parentcontexttest, $parentcontextparams) =
719 $DB->get_in_or_equal($parentcontextids, SQL_PARAMS_NAMED
, 'parentcontext');
720 $contexttest = "($contexttest OR (bi.showinsubcontexts = 1 AND bi.parentcontextid $parentcontexttest))";
723 $pagetypepatterns = matching_page_type_patterns($this->page
->pagetype
);
724 list($pagetypepatterntest, $pagetypepatternparams) =
725 $DB->get_in_or_equal($pagetypepatterns, SQL_PARAMS_NAMED
, 'pagetypepatterntest');
727 $ccselect = ', ' . context_helper
::get_preload_record_columns_sql('ctx');
728 $ccjoin = "LEFT JOIN {context} ctx ON (ctx.instanceid = bi.id AND ctx.contextlevel = :contextlevel)";
730 $systemcontext = context_system
::instance();
732 'contextlevel' => CONTEXT_BLOCK
,
733 'subpage1' => $this->page
->subpage
,
734 'subpage2' => $this->page
->subpage
,
735 'subpage3' => $this->page
->subpage
,
736 'contextid1' => $context->id
,
737 'contextid2' => $context->id
,
738 'contextid3' => $systemcontext->id
,
739 'contextid4' => $systemcontext->id
,
740 'pagetype' => $this->page
->pagetype
,
741 'pagetype2' => $this->page
->pagetype
,
743 if ($this->page
->subpage
=== '') {
744 $params['subpage1'] = '';
745 $params['subpage2'] = '';
746 $params['subpage3'] = '';
750 COALESCE(bp.id, bs.id) AS blockpositionid,
753 bi.showinsubcontexts,
759 COALESCE(bp.visible, bs.visible, 1) AS visible,
760 COALESCE(bp.region, bs.region, bi.defaultregion) AS region,
761 COALESCE(bp.weight, bs.weight, bi.defaultweight) AS weight,
765 FROM {block_instances} bi
766 JOIN {block} b ON bi.blockname = b.name
767 LEFT JOIN {block_positions} bp ON bp.blockinstanceid = bi.id
768 AND bp.contextid = :contextid1
769 AND bp.pagetype = :pagetype
770 AND bp.subpage = :subpage1
771 LEFT JOIN {block_positions} bs ON bs.blockinstanceid = bi.id
772 AND bs.contextid = :contextid4
773 AND bs.pagetype = :pagetype2
774 AND bs.subpage = :subpage3
779 AND bi.pagetypepattern $pagetypepatterntest
780 AND (bi.subpagepattern IS NULL OR bi.subpagepattern = :subpage2)
783 $requiredbythemecheck
786 COALESCE(bp.region, bs.region, bi.defaultregion),
787 COALESCE(bp.weight, bs.weight, bi.defaultweight),
790 $allparams = $params +
$parentcontextparams +
$pagetypepatternparams +
$requiredbythemeparams +
$requiredbythemenotparams;
791 $blockinstances = $DB->get_recordset_sql($sql, $allparams);
793 $this->birecordsbyregion
= $this->prepare_per_region_arrays();
795 foreach ($blockinstances as $bi) {
796 context_helper
::preload_from_record($bi);
797 if ($this->is_known_region($bi->region
)) {
798 $this->birecordsbyregion
[$bi->region
][] = $bi;
804 // Pages don't necessarily have a defaultregion. The one time this can
805 // happen is when there are no theme block regions, but the script itself
806 // has a block region in the main content area.
807 if (!empty($this->defaultregion
)) {
808 $this->birecordsbyregion
[$this->defaultregion
] =
809 array_merge($this->birecordsbyregion
[$this->defaultregion
], $unknown);
814 * Add a block to the current page, or related pages. The block is added to
815 * context $this->page->contextid. If $pagetypepattern $subpagepattern
817 * @param string $blockname The type of block to add.
818 * @param string $region the block region on this page to add the block to.
819 * @param integer $weight determines the order where this block appears in the region.
820 * @param boolean $showinsubcontexts whether this block appears in subcontexts, or just the current context.
821 * @param string|null $pagetypepattern which page types this block should appear on. Defaults to just the current page type.
822 * @param string|null $subpagepattern which subpage this block should appear on. NULL = any (the default), otherwise only the specified subpage.
824 public function add_block($blockname, $region, $weight, $showinsubcontexts, $pagetypepattern = NULL, $subpagepattern = NULL) {
826 // Allow invisible blocks because this is used when adding default page blocks, which
827 // might include invisible ones if the user makes some default blocks invisible
828 $this->check_known_block_type($blockname, true);
829 $this->check_region_is_known($region);
831 if (empty($pagetypepattern)) {
832 $pagetypepattern = $this->page
->pagetype
;
835 $blockinstance = new stdClass
;
836 $blockinstance->blockname
= $blockname;
837 $blockinstance->parentcontextid
= $this->page
->context
->id
;
838 $blockinstance->showinsubcontexts
= !empty($showinsubcontexts);
839 $blockinstance->pagetypepattern
= $pagetypepattern;
840 $blockinstance->subpagepattern
= $subpagepattern;
841 $blockinstance->defaultregion
= $region;
842 $blockinstance->defaultweight
= $weight;
843 $blockinstance->configdata
= '';
844 $blockinstance->id
= $DB->insert_record('block_instances', $blockinstance);
846 // Ensure the block context is created.
847 context_block
::instance($blockinstance->id
);
849 // If the new instance was created, allow it to do additional setup
850 if ($block = block_instance($blockname, $blockinstance)) {
851 $block->instance_create();
855 public function add_block_at_end_of_default_region($blockname) {
856 if (empty($this->birecordsbyregion
)) {
857 // No blocks or block regions exist yet.
860 $defaulregion = $this->get_default_region();
862 $lastcurrentblock = end($this->birecordsbyregion
[$defaulregion]);
863 if ($lastcurrentblock) {
864 $weight = $lastcurrentblock->weight +
1;
869 if ($this->page
->subpage
) {
870 $subpage = $this->page
->subpage
;
875 // Special case. Course view page type include the course format, but we
876 // want to add the block non-format-specifically.
877 $pagetypepattern = $this->page
->pagetype
;
878 if (strpos($pagetypepattern, 'course-view') === 0) {
879 $pagetypepattern = 'course-view-*';
882 // We should end using this for ALL the blocks, making always the 1st option
883 // the default one to be used. Until then, this is one hack to avoid the
884 // 'pagetypewarning' message on blocks initial edition (MDL-27829) caused by
885 // non-existing $pagetypepattern set. This way at least we guarantee one "valid"
886 // (the FIRST $pagetypepattern will be set)
888 // We are applying it to all blocks created in mod pages for now and only if the
889 // default pagetype is not one of the available options
890 if (preg_match('/^mod-.*-/', $pagetypepattern)) {
891 $pagetypelist = generate_page_type_patterns($this->page
->pagetype
, null, $this->page
->context
);
892 // Only go for the first if the pagetype is not a valid option
893 if (is_array($pagetypelist) && !array_key_exists($pagetypepattern, $pagetypelist)) {
894 $pagetypepattern = key($pagetypelist);
897 // Surely other pages like course-report will need this too, they just are not important
898 // enough now. This will be decided in the coming days. (MDL-27829, MDL-28150)
900 $this->add_block($blockname, $defaulregion, $weight, false, $pagetypepattern, $subpage);
904 * Convenience method, calls add_block repeatedly for all the blocks in $blocks. Optionally, a starting weight
905 * can be used to decide the starting point that blocks are added in the region, the weight is passed to {@link add_block}
906 * and incremented by the position of the block in the $blocks array
908 * @param array $blocks array with array keys the region names, and values an array of block names.
909 * @param string $pagetypepattern optional. Passed to {@link add_block()}
910 * @param string $subpagepattern optional. Passed to {@link add_block()}
911 * @param boolean $showinsubcontexts optional. Passed to {@link add_block()}
912 * @param integer $weight optional. Determines the starting point that the blocks are added in the region.
914 public function add_blocks($blocks, $pagetypepattern = NULL, $subpagepattern = NULL, $showinsubcontexts=false, $weight=0) {
915 $initialweight = $weight;
916 $this->add_regions(array_keys($blocks), false);
917 foreach ($blocks as $region => $regionblocks) {
918 foreach ($regionblocks as $offset => $blockname) {
919 $weight = $initialweight +
$offset;
920 $this->add_block($blockname, $region, $weight, $showinsubcontexts, $pagetypepattern, $subpagepattern);
926 * Move a block to a new position on this page.
928 * If this block cannot appear on any other pages, then we change defaultposition/weight
929 * in the block_instances table. Otherwise we just set the position on this page.
931 * @param $blockinstanceid the block instance id.
932 * @param $newregion the new region name.
933 * @param $newweight the new weight.
935 public function reposition_block($blockinstanceid, $newregion, $newweight) {
938 $this->check_region_is_known($newregion);
939 $inst = $this->find_instance($blockinstanceid);
941 $bi = $inst->instance
;
942 if ($bi->weight
== $bi->defaultweight
&& $bi->region
== $bi->defaultregion
&&
943 !$bi->showinsubcontexts
&& strpos($bi->pagetypepattern
, '*') === false &&
944 (!$this->page
->subpage ||
$bi->subpagepattern
)) {
946 // Set default position
947 $newbi = new stdClass
;
948 $newbi->id
= $bi->id
;
949 $newbi->defaultregion
= $newregion;
950 $newbi->defaultweight
= $newweight;
951 $DB->update_record('block_instances', $newbi);
953 if ($bi->blockpositionid
) {
955 $bp->id
= $bi->blockpositionid
;
956 $bp->region
= $newregion;
957 $bp->weight
= $newweight;
958 $DB->update_record('block_positions', $bp);
962 // Just set position on this page.
964 $bp->region
= $newregion;
965 $bp->weight
= $newweight;
967 if ($bi->blockpositionid
) {
968 $bp->id
= $bi->blockpositionid
;
969 $DB->update_record('block_positions', $bp);
972 $bp->blockinstanceid
= $bi->id
;
973 $bp->contextid
= $this->page
->context
->id
;
974 $bp->pagetype
= $this->page
->pagetype
;
975 if ($this->page
->subpage
) {
976 $bp->subpage
= $this->page
->subpage
;
980 $bp->visible
= $bi->visible
;
981 $DB->insert_record('block_positions', $bp);
987 * Find a given block by its instance id
989 * @param integer $instanceid
992 public function find_instance($instanceid) {
993 foreach ($this->regions
as $region => $notused) {
994 $this->ensure_instances_exist($region);
995 foreach($this->blockinstances
[$region] as $instance) {
996 if ($instance->instance
->id
== $instanceid) {
1001 throw new block_not_on_page_exception($instanceid, $this->page
);
1004 /// Inner workings =============================================================
1007 * Check whether the page blocks have been loaded yet
1009 * @return void Throws coding exception if already loaded
1011 protected function check_not_yet_loaded() {
1012 if (!is_null($this->birecordsbyregion
)) {
1013 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.');
1018 * Check whether the page blocks have been loaded yet
1020 * Nearly identical to the above function {@link check_not_yet_loaded()} except different message
1022 * @return void Throws coding exception if already loaded
1024 protected function check_is_loaded() {
1025 if (is_null($this->birecordsbyregion
)) {
1026 throw new coding_exception('block_manager has not yet loaded the blocks, to it is too soon to request the information you asked for.');
1031 * Check if a block type is known and usable
1033 * @param string $blockname The block type name to search for
1034 * @param bool $includeinvisible Include disabled block types in the initial pass
1035 * @return void Coding Exception thrown if unknown or not enabled
1037 protected function check_known_block_type($blockname, $includeinvisible = false) {
1038 if (!$this->is_known_block_type($blockname, $includeinvisible)) {
1039 if ($this->is_known_block_type($blockname, true)) {
1040 throw new coding_exception('Unknown block type ' . $blockname);
1042 throw new coding_exception('Block type ' . $blockname . ' has been disabled by the administrator.');
1048 * Check if a region is known by its name
1050 * @param string $region
1051 * @return void Coding Exception thrown if the region is not known
1053 protected function check_region_is_known($region) {
1054 if (!$this->is_known_region($region)) {
1055 throw new coding_exception('Trying to reference an unknown block region ' . $region);
1060 * Returns an array of region names as keys and nested arrays for values
1062 * @return array an array where the array keys are the region names, and the array
1063 * values are empty arrays.
1065 protected function prepare_per_region_arrays() {
1067 foreach ($this->regions
as $region => $notused) {
1068 $result[$region] = array();
1074 * Create a set of new block instance from a record array
1076 * @param array $birecords An array of block instance records
1077 * @return array An array of instantiated block_instance objects
1079 protected function create_block_instances($birecords) {
1081 foreach ($birecords as $record) {
1082 if ($blockobject = block_instance($record->blockname
, $record, $this->page
)) {
1083 $results[] = $blockobject;
1090 * Create all the block instances for all the blocks that were loaded by
1091 * load_blocks. This is used, for example, to ensure that all blocks get a
1092 * chance to initialise themselves via the {@link block_base::specialize()}
1093 * method, before any output is done.
1095 * It is also used to create any blocks that are "requiredbytheme" by the current theme.
1096 * These blocks that are auto-created have requiredbytheme set on the block instance
1097 * so they are only visible on themes that require them.
1099 public function create_all_block_instances() {
1102 // If there are any un-removable blocks that were not created - force them.
1103 $requiredbytheme = $this->get_required_by_theme_block_types();
1104 if (!$this->fakeblocksonly
) {
1105 foreach ($requiredbytheme as $forced) {
1106 if (empty($forced)) {
1110 foreach ($this->get_regions() as $region) {
1111 foreach($this->birecordsbyregion
[$region] as $instance) {
1112 if ($instance->blockname
== $forced) {
1118 $this->add_block_required_by_theme($forced);
1125 // Some blocks were missing. Lets do it again.
1126 $this->birecordsbyregion
= null;
1127 $this->load_blocks();
1129 foreach ($this->get_regions() as $region) {
1130 $this->ensure_instances_exist($region);
1136 * Add a block that is required by the current theme but has not been
1137 * created yet. This is a special type of block that only shows in themes that
1138 * require it (by listing it in undeletable_block_types).
1140 * @param string $blockname the name of the block type.
1142 protected function add_block_required_by_theme($blockname) {
1145 if (empty($this->birecordsbyregion
)) {
1146 // No blocks or block regions exist yet.
1150 // Never auto create blocks when we are showing fake blocks only.
1151 if ($this->fakeblocksonly
) {
1155 // Never add a duplicate block required by theme.
1156 if ($DB->record_exists('block_instances', array('blockname' => $blockname, 'requiredbytheme' => 1))) {
1160 $systemcontext = context_system
::instance();
1161 $defaultregion = $this->get_default_region();
1162 // Add a special system wide block instance only for themes that require it.
1163 $blockinstance = new stdClass
;
1164 $blockinstance->blockname
= $blockname;
1165 $blockinstance->parentcontextid
= $systemcontext->id
;
1166 $blockinstance->showinsubcontexts
= true;
1167 $blockinstance->requiredbytheme
= true;
1168 $blockinstance->pagetypepattern
= '*';
1169 $blockinstance->subpagepattern
= null;
1170 $blockinstance->defaultregion
= $defaultregion;
1171 $blockinstance->defaultweight
= 0;
1172 $blockinstance->configdata
= '';
1173 $blockinstance->id
= $DB->insert_record('block_instances', $blockinstance);
1175 // Ensure the block context is created.
1176 context_block
::instance($blockinstance->id
);
1178 // If the new instance was created, allow it to do additional setup.
1179 if ($block = block_instance($blockname, $blockinstance)) {
1180 $block->instance_create();
1185 * Return an array of content objects from a set of block instances
1187 * @param array $instances An array of block instances
1188 * @param renderer_base The renderer to use.
1189 * @param string $region the region name.
1190 * @return array An array of block_content (and possibly block_move_target) objects.
1192 protected function create_block_contents($instances, $output, $region) {
1197 if ($this->movingblock
) {
1198 $first = reset($instances);
1200 $lastweight = $first->instance
->weight
- 2;
1204 foreach ($instances as $instance) {
1205 $content = $instance->get_content_for_output($output);
1206 if (empty($content)) {
1210 if ($this->movingblock
&& $lastweight != $instance->instance
->weight
&&
1211 $content->blockinstanceid
!= $this->movingblock
&& $lastblock != $this->movingblock
) {
1212 $results[] = new block_move_target($this->get_move_target_url($region, ($lastweight +
$instance->instance
->weight
)/2));
1215 if ($content->blockinstanceid
== $this->movingblock
) {
1216 $content->add_class('beingmoved');
1217 $content->annotation
.= get_string('movingthisblockcancel', 'block',
1218 html_writer
::link($this->page
->url
, get_string('cancel')));
1221 $results[] = $content;
1222 $lastweight = $instance->instance
->weight
;
1223 $lastblock = $instance->instance
->id
;
1226 if ($this->movingblock
&& $lastblock != $this->movingblock
) {
1227 $results[] = new block_move_target($this->get_move_target_url($region, $lastweight +
1));
1233 * Ensure block instances exist for a given region
1235 * @param string $region Check for bi's with the instance with this name
1237 protected function ensure_instances_exist($region) {
1238 $this->check_region_is_known($region);
1239 if (!array_key_exists($region, $this->blockinstances
)) {
1240 $this->blockinstances
[$region] =
1241 $this->create_block_instances($this->birecordsbyregion
[$region]);
1246 * Ensure that there is some content within the given region
1248 * @param string $region The name of the region to check
1250 public function ensure_content_created($region, $output) {
1251 $this->ensure_instances_exist($region);
1252 if (!array_key_exists($region, $this->visibleblockcontent
)) {
1253 $contents = array();
1254 if (array_key_exists($region, $this->extracontent
)) {
1255 $contents = $this->extracontent
[$region];
1257 $contents = array_merge($contents, $this->create_block_contents($this->blockinstances
[$region], $output, $region));
1258 if (($region == $this->defaultregion
) && (!isset($this->page
->theme
->addblockposition
) ||
1259 $this->page
->theme
->addblockposition
== BLOCK_ADDBLOCK_POSITION_DEFAULT
)) {
1260 $addblockui = block_add_block_ui($this->page
, $output);
1262 $contents[] = $addblockui;
1265 $this->visibleblockcontent
[$region] = $contents;
1269 /// Process actions from the URL ===============================================
1272 * Get the appropriate list of editing icons for a block. This is used
1273 * to set {@link block_contents::$controls} in {@link block_base::get_contents_for_output()}.
1275 * @param $output The core_renderer to use when generating the output. (Need to get icon paths.)
1276 * @return an array in the format for {@link block_contents::$controls}
1278 public function edit_controls($block) {
1281 $controls = array();
1282 $actionurl = $this->page
->url
->out(false, array('sesskey'=> sesskey()));
1283 $blocktitle = $block->title
;
1284 if (empty($blocktitle)) {
1285 $blocktitle = $block->arialabel
;
1288 if ($this->page
->user_can_edit_blocks()) {
1290 $str = new lang_string('moveblock', 'block', $blocktitle);
1291 $controls[] = new action_menu_link_primary(
1292 new moodle_url($actionurl, array('bui_moveid' => $block->instance
->id
)),
1293 new pix_icon('t/move', $str, 'moodle', array('class' => 'iconsmall', 'title' => '')),
1295 array('class' => 'editing_move')
1300 if ($this->page
->user_can_edit_blocks() ||
$block->user_can_edit()) {
1301 // Edit config icon - always show - needed for positioning UI.
1302 $str = new lang_string('configureblock', 'block', $blocktitle);
1303 $controls[] = new action_menu_link_secondary(
1304 new moodle_url($actionurl, array('bui_editid' => $block->instance
->id
)),
1305 new pix_icon('t/edit', $str, 'moodle', array('class' => 'iconsmall', 'title' => '')),
1307 array('class' => 'editing_edit')
1312 if ($this->page
->user_can_edit_blocks() && $block->instance_can_be_hidden()) {
1314 if ($block->instance
->visible
) {
1315 $str = new lang_string('hideblock', 'block', $blocktitle);
1316 $url = new moodle_url($actionurl, array('bui_hideid' => $block->instance
->id
));
1317 $icon = new pix_icon('t/hide', $str, 'moodle', array('class' => 'iconsmall', 'title' => ''));
1318 $attributes = array('class' => 'editing_hide');
1320 $str = new lang_string('showblock', 'block', $blocktitle);
1321 $url = new moodle_url($actionurl, array('bui_showid' => $block->instance
->id
));
1322 $icon = new pix_icon('t/show', $str, 'moodle', array('class' => 'iconsmall', 'title' => ''));
1323 $attributes = array('class' => 'editing_show');
1325 $controls[] = new action_menu_link_secondary($url, $icon, $str, $attributes);
1329 if (get_assignable_roles($block->context
, ROLENAME_SHORT
)) {
1330 $rolesurl = new moodle_url('/admin/roles/assign.php', array('contextid' => $block->context
->id
,
1331 'returnurl' => $this->page
->url
->out_as_local_url()));
1332 $str = new lang_string('assignrolesinblock', 'block', $blocktitle);
1333 $controls[] = new action_menu_link_secondary(
1335 new pix_icon('i/assignroles', $str, 'moodle', array('class' => 'iconsmall', 'title' => '')),
1336 $str, array('class' => 'editing_assignroles')
1341 if (has_capability('moodle/role:review', $block->context
) or get_overridable_roles($block->context
)) {
1342 $rolesurl = new moodle_url('/admin/roles/permissions.php', array('contextid' => $block->context
->id
,
1343 'returnurl' => $this->page
->url
->out_as_local_url()));
1344 $str = get_string('permissions', 'role');
1345 $controls[] = new action_menu_link_secondary(
1347 new pix_icon('i/permissions', $str, 'moodle', array('class' => 'iconsmall', 'title' => '')),
1348 $str, array('class' => 'editing_permissions')
1352 // Change permissions.
1353 if (has_any_capability(array('moodle/role:safeoverride', 'moodle/role:override', 'moodle/role:assign'), $block->context
)) {
1354 $rolesurl = new moodle_url('/admin/roles/check.php', array('contextid' => $block->context
->id
,
1355 'returnurl' => $this->page
->url
->out_as_local_url()));
1356 $str = get_string('checkpermissions', 'role');
1357 $controls[] = new action_menu_link_secondary(
1359 new pix_icon('i/checkpermissions', $str, 'moodle', array('class' => 'iconsmall', 'title' => '')),
1360 $str, array('class' => 'editing_checkroles')
1364 if ($this->user_can_delete_block($block)) {
1366 $str = new lang_string('deleteblock', 'block', $blocktitle);
1367 $controls[] = new action_menu_link_secondary(
1368 new moodle_url($actionurl, array('bui_deleteid' => $block->instance
->id
)),
1369 new pix_icon('t/delete', $str, 'moodle', array('class' => 'iconsmall', 'title' => '')),
1371 array('class' => 'editing_delete')
1379 * @param block_base $block a block that appears on this page.
1380 * @return boolean boolean whether the currently logged in user is allowed to delete this block.
1382 protected function user_can_delete_block($block) {
1383 return $this->page
->user_can_edit_blocks() && $block->user_can_edit() &&
1384 $block->user_can_addto($this->page
) &&
1385 !in_array($block->instance
->blockname
, self
::get_undeletable_block_types()) &&
1386 !in_array($block->instance
->blockname
, $this->get_required_by_theme_block_types());
1390 * Process any block actions that were specified in the URL.
1392 * @return boolean true if anything was done. False if not.
1394 public function process_url_actions() {
1395 if (!$this->page
->user_is_editing()) {
1398 return $this->process_url_add() ||
$this->process_url_delete() ||
1399 $this->process_url_show_hide() ||
$this->process_url_edit() ||
1400 $this->process_url_move();
1404 * Handle adding a block.
1405 * @return boolean true if anything was done. False if not.
1407 public function process_url_add() {
1408 global $CFG, $PAGE, $OUTPUT;
1410 $blocktype = optional_param('bui_addblock', null, PARAM_PLUGIN
);
1411 if ($blocktype === null) {
1417 if (!$this->page
->user_can_edit_blocks()) {
1418 throw new moodle_exception('nopermissions', '', $this->page
->url
->out(), get_string('addblock'));
1421 $addableblocks = $this->get_addable_blocks();
1423 if ($blocktype === '') {
1424 // Display add block selection.
1425 $addpage = new moodle_page();
1426 $addpage->set_pagelayout('admin');
1427 $addpage->blocks
->show_only_fake_blocks(true);
1428 $addpage->set_course($this->page
->course
);
1429 $addpage->set_context($this->page
->context
);
1430 if ($this->page
->cm
) {
1431 $addpage->set_cm($this->page
->cm
);
1434 $addpagebase = str_replace($CFG->wwwroot
. '/', '/', $this->page
->url
->out_omit_querystring());
1435 $addpageparams = $this->page
->url
->params();
1436 $addpage->set_url($addpagebase, $addpageparams);
1437 $addpage->set_block_actions_done();
1438 // At this point we are going to display the block selector, overwrite global $PAGE ready for this.
1440 // Some functions use $OUTPUT so we need to replace that too.
1441 $OUTPUT = $addpage->get_renderer('core');
1444 $straddblock = get_string('addblock');
1446 $PAGE->navbar
->add($straddblock);
1447 $PAGE->set_title($straddblock);
1448 $PAGE->set_heading($site->fullname
);
1449 echo $OUTPUT->header();
1450 echo $OUTPUT->heading($straddblock);
1452 if (!$addableblocks) {
1453 echo $OUTPUT->box(get_string('noblockstoaddhere'));
1454 echo $OUTPUT->container($OUTPUT->action_link($addpage->url
, get_string('back')), 'm-x-3 m-b-1');
1456 $url = new moodle_url($addpage->url
, array('sesskey' => sesskey()));
1457 echo $OUTPUT->render_from_template('core/add_block_body',
1458 ['blocks' => array_values($addableblocks),
1459 'url' => '?' . $url->get_query_string(false)]);
1460 echo $OUTPUT->container($OUTPUT->action_link($addpage->url
, get_string('cancel')), 'm-x-3 m-b-1');
1463 echo $OUTPUT->footer();
1464 // Make sure that nothing else happens after we have displayed this form.
1468 if (!array_key_exists($blocktype, $addableblocks)) {
1469 throw new moodle_exception('cannotaddthisblocktype', '', $this->page
->url
->out(), $blocktype);
1472 $this->add_block_at_end_of_default_region($blocktype);
1474 // If the page URL was a guess, it will contain the bui_... param, so we must make sure it is not there.
1475 $this->page
->ensure_param_not_in_url('bui_addblock');
1481 * Handle deleting a block.
1482 * @return boolean true if anything was done. False if not.
1484 public function process_url_delete() {
1485 global $CFG, $PAGE, $OUTPUT;
1487 $blockid = optional_param('bui_deleteid', null, PARAM_INT
);
1488 $confirmdelete = optional_param('bui_confirm', null, PARAM_INT
);
1495 $block = $this->page
->blocks
->find_instance($blockid);
1496 if (!$this->user_can_delete_block($block)) {
1497 throw new moodle_exception('nopermissions', '', $this->page
->url
->out(), get_string('deleteablock'));
1500 if (!$confirmdelete) {
1501 $deletepage = new moodle_page();
1502 $deletepage->set_pagelayout('admin');
1503 $deletepage->blocks
->show_only_fake_blocks(true);
1504 $deletepage->set_course($this->page
->course
);
1505 $deletepage->set_context($this->page
->context
);
1506 if ($this->page
->cm
) {
1507 $deletepage->set_cm($this->page
->cm
);
1510 $deleteurlbase = str_replace($CFG->wwwroot
. '/', '/', $this->page
->url
->out_omit_querystring());
1511 $deleteurlparams = $this->page
->url
->params();
1512 $deletepage->set_url($deleteurlbase, $deleteurlparams);
1513 $deletepage->set_block_actions_done();
1514 // At this point we are either going to redirect, or display the form, so
1515 // overwrite global $PAGE ready for this. (Formslib refers to it.)
1516 $PAGE = $deletepage;
1517 //some functions like MoodleQuickForm::addHelpButton use $OUTPUT so we need to replace that too
1518 $output = $deletepage->get_renderer('core');
1522 $blocktitle = $block->get_title();
1523 $strdeletecheck = get_string('deletecheck', 'block', $blocktitle);
1524 $message = get_string('deleteblockcheck', 'block', $blocktitle);
1526 // If the block is being shown in sub contexts display a warning.
1527 if ($block->instance
->showinsubcontexts
== 1) {
1528 $parentcontext = context
::instance_by_id($block->instance
->parentcontextid
);
1529 $systemcontext = context_system
::instance();
1530 $messagestring = new stdClass();
1531 $messagestring->location
= $parentcontext->get_context_name();
1533 // Checking for blocks that may have visibility on the front page and pages added on that.
1534 if ($parentcontext->id
!= $systemcontext->id
&& is_inside_frontpage($parentcontext)) {
1535 $messagestring->pagetype
= get_string('showonfrontpageandsubs', 'block');
1537 $pagetypes = generate_page_type_patterns($this->page
->pagetype
, $parentcontext);
1538 $messagestring->pagetype
= $block->instance
->pagetypepattern
;
1539 if (isset($pagetypes[$block->instance
->pagetypepattern
])) {
1540 $messagestring->pagetype
= $pagetypes[$block->instance
->pagetypepattern
];
1544 $message = get_string('deleteblockwarning', 'block', $messagestring);
1547 $PAGE->navbar
->add($strdeletecheck);
1548 $PAGE->set_title($blocktitle . ': ' . $strdeletecheck);
1549 $PAGE->set_heading($site->fullname
);
1550 echo $OUTPUT->header();
1551 $confirmurl = new moodle_url($deletepage->url
, array('sesskey' => sesskey(), 'bui_deleteid' => $block->instance
->id
, 'bui_confirm' => 1));
1552 $cancelurl = new moodle_url($deletepage->url
);
1553 $yesbutton = new single_button($confirmurl, get_string('yes'));
1554 $nobutton = new single_button($cancelurl, get_string('no'));
1555 echo $OUTPUT->confirm($message, $yesbutton, $nobutton);
1556 echo $OUTPUT->footer();
1557 // Make sure that nothing else happens after we have displayed this form.
1560 blocks_delete_instance($block->instance
);
1561 // bui_deleteid and bui_confirm should not be in the PAGE url.
1562 $this->page
->ensure_param_not_in_url('bui_deleteid');
1563 $this->page
->ensure_param_not_in_url('bui_confirm');
1569 * Handle showing or hiding a block.
1570 * @return boolean true if anything was done. False if not.
1572 public function process_url_show_hide() {
1573 if ($blockid = optional_param('bui_hideid', null, PARAM_INT
)) {
1575 } else if ($blockid = optional_param('bui_showid', null, PARAM_INT
)) {
1583 $block = $this->page
->blocks
->find_instance($blockid);
1585 if (!$this->page
->user_can_edit_blocks()) {
1586 throw new moodle_exception('nopermissions', '', $this->page
->url
->out(), get_string('hideshowblocks'));
1587 } else if (!$block->instance_can_be_hidden()) {
1591 blocks_set_visibility($block->instance
, $this->page
, $newvisibility);
1593 // If the page URL was a guses, it will contain the bui_... param, so we must make sure it is not there.
1594 $this->page
->ensure_param_not_in_url('bui_hideid');
1595 $this->page
->ensure_param_not_in_url('bui_showid');
1601 * Handle showing/processing the submission from the block editing form.
1602 * @return boolean true if the form was submitted and the new config saved. Does not
1603 * return if the editing form was displayed. False otherwise.
1605 public function process_url_edit() {
1606 global $CFG, $DB, $PAGE, $OUTPUT;
1608 $blockid = optional_param('bui_editid', null, PARAM_INT
);
1614 require_once($CFG->dirroot
. '/blocks/edit_form.php');
1616 $block = $this->find_instance($blockid);
1618 if (!$block->user_can_edit() && !$this->page
->user_can_edit_blocks()) {
1619 throw new moodle_exception('nopermissions', '', $this->page
->url
->out(), get_string('editblock'));
1622 $editpage = new moodle_page();
1623 $editpage->set_pagelayout('admin');
1624 $editpage->blocks
->show_only_fake_blocks(true);
1625 $editpage->set_course($this->page
->course
);
1626 //$editpage->set_context($block->context);
1627 $editpage->set_context($this->page
->context
);
1628 if ($this->page
->cm
) {
1629 $editpage->set_cm($this->page
->cm
);
1631 $editurlbase = str_replace($CFG->wwwroot
. '/', '/', $this->page
->url
->out_omit_querystring());
1632 $editurlparams = $this->page
->url
->params();
1633 $editurlparams['bui_editid'] = $blockid;
1634 $editpage->set_url($editurlbase, $editurlparams);
1635 $editpage->set_block_actions_done();
1636 // At this point we are either going to redirect, or display the form, so
1637 // overwrite global $PAGE ready for this. (Formslib refers to it.)
1639 //some functions like MoodleQuickForm::addHelpButton use $OUTPUT so we need to replace that to
1640 $output = $editpage->get_renderer('core');
1643 $formfile = $CFG->dirroot
. '/blocks/' . $block->name() . '/edit_form.php';
1644 if (is_readable($formfile)) {
1645 require_once($formfile);
1646 $classname = 'block_' . $block->name() . '_edit_form';
1647 if (!class_exists($classname)) {
1648 $classname = 'block_edit_form';
1651 $classname = 'block_edit_form';
1654 $mform = new $classname($editpage->url
, $block, $this->page
);
1655 $mform->set_data($block->instance
);
1657 if ($mform->is_cancelled()) {
1658 redirect($this->page
->url
);
1660 } else if ($data = $mform->get_data()) {
1662 $bi->id
= $block->instance
->id
;
1664 // This may get overwritten by the special case handling below.
1665 $bi->pagetypepattern
= $data->bui_pagetypepattern
;
1666 $bi->showinsubcontexts
= (bool) $data->bui_contexts
;
1667 if (empty($data->bui_subpagepattern
) ||
$data->bui_subpagepattern
== '%@NULL@%') {
1668 $bi->subpagepattern
= null;
1670 $bi->subpagepattern
= $data->bui_subpagepattern
;
1673 $systemcontext = context_system
::instance();
1674 $frontpagecontext = context_course
::instance(SITEID
);
1675 $parentcontext = context
::instance_by_id($data->bui_parentcontextid
);
1677 // Updating stickiness and contexts. See MDL-21375 for details.
1678 if (has_capability('moodle/site:manageblocks', $parentcontext)) { // Check permissions in destination
1680 // Explicitly set the default context
1681 $bi->parentcontextid
= $parentcontext->id
;
1683 if ($data->bui_editingatfrontpage
) { // The block is being edited on the front page
1685 // The interface here is a special case because the pagetype pattern is
1686 // totally derived from the context menu. Here are the excpetions. MDL-30340
1688 switch ($data->bui_contexts
) {
1689 case BUI_CONTEXTS_ENTIRE_SITE
:
1690 // The user wants to show the block across the entire site
1691 $bi->parentcontextid
= $systemcontext->id
;
1692 $bi->showinsubcontexts
= true;
1693 $bi->pagetypepattern
= '*';
1695 case BUI_CONTEXTS_FRONTPAGE_SUBS
:
1696 // The user wants the block shown on the front page and all subcontexts
1697 $bi->parentcontextid
= $frontpagecontext->id
;
1698 $bi->showinsubcontexts
= true;
1699 $bi->pagetypepattern
= '*';
1701 case BUI_CONTEXTS_FRONTPAGE_ONLY
:
1702 // The user want to show the front page on the frontpage only
1703 $bi->parentcontextid
= $frontpagecontext->id
;
1704 $bi->showinsubcontexts
= false;
1705 $bi->pagetypepattern
= 'site-index';
1706 // This is the only relevant page type anyway but we'll set it explicitly just
1707 // in case the front page grows site-index-* subpages of its own later
1713 $bits = explode('-', $bi->pagetypepattern
);
1714 // hacks for some contexts
1715 if (($parentcontext->contextlevel
== CONTEXT_COURSE
) && ($parentcontext->instanceid
!= SITEID
)) {
1716 // For course context
1717 // is page type pattern is mod-*, change showinsubcontext to 1
1718 if ($bits[0] == 'mod' ||
$bi->pagetypepattern
== '*') {
1719 $bi->showinsubcontexts
= 1;
1721 $bi->showinsubcontexts
= 0;
1723 } else if ($parentcontext->contextlevel
== CONTEXT_USER
) {
1725 // subpagepattern should be null
1726 if ($bits[0] == 'user' or $bits[0] == 'my') {
1727 // we don't need subpagepattern in usercontext
1728 $bi->subpagepattern
= null;
1732 $bi->defaultregion
= $data->bui_defaultregion
;
1733 $bi->defaultweight
= $data->bui_defaultweight
;
1734 $DB->update_record('block_instances', $bi);
1736 if (!empty($block->config
)) {
1737 $config = clone($block->config
);
1739 $config = new stdClass
;
1741 foreach ($data as $configfield => $value) {
1742 if (strpos($configfield, 'config_') !== 0) {
1745 $field = substr($configfield, 7);
1746 $config->$field = $value;
1748 $block->instance_config_save($config);
1751 $bp->visible
= $data->bui_visible
;
1752 $bp->region
= $data->bui_region
;
1753 $bp->weight
= $data->bui_weight
;
1754 $needbprecord = !$data->bui_visible ||
$data->bui_region
!= $data->bui_defaultregion ||
1755 $data->bui_weight
!= $data->bui_defaultweight
;
1757 if ($block->instance
->blockpositionid
&& !$needbprecord) {
1758 $DB->delete_records('block_positions', array('id' => $block->instance
->blockpositionid
));
1760 } else if ($block->instance
->blockpositionid
&& $needbprecord) {
1761 $bp->id
= $block->instance
->blockpositionid
;
1762 $DB->update_record('block_positions', $bp);
1764 } else if ($needbprecord) {
1765 $bp->blockinstanceid
= $block->instance
->id
;
1766 $bp->contextid
= $this->page
->context
->id
;
1767 $bp->pagetype
= $this->page
->pagetype
;
1768 if ($this->page
->subpage
) {
1769 $bp->subpage
= $this->page
->subpage
;
1773 $DB->insert_record('block_positions', $bp);
1776 redirect($this->page
->url
);
1779 $strheading = get_string('blockconfiga', 'moodle', $block->get_title());
1780 $editpage->set_title($strheading);
1781 $editpage->set_heading($strheading);
1782 $bits = explode('-', $this->page
->pagetype
);
1783 if ($bits[0] == 'tag' && !empty($this->page
->subpage
)) {
1784 // better navbar for tag pages
1785 $editpage->navbar
->add(get_string('tags'), new moodle_url('/tag/'));
1786 $tag = core_tag_tag
::get($this->page
->subpage
);
1787 // tag search page doesn't have subpageid
1789 $editpage->navbar
->add($tag->get_display_name(), $tag->get_view_url());
1792 $editpage->navbar
->add($block->get_title());
1793 $editpage->navbar
->add(get_string('configuration'));
1794 echo $output->header();
1795 echo $output->heading($strheading, 2);
1797 echo $output->footer();
1803 * Handle showing/processing the submission from the block editing form.
1804 * @return boolean true if the form was submitted and the new config saved. Does not
1805 * return if the editing form was displayed. False otherwise.
1807 public function process_url_move() {
1808 global $CFG, $DB, $PAGE;
1810 $blockid = optional_param('bui_moveid', null, PARAM_INT
);
1817 $block = $this->find_instance($blockid);
1819 if (!$this->page
->user_can_edit_blocks()) {
1820 throw new moodle_exception('nopermissions', '', $this->page
->url
->out(), get_string('editblock'));
1823 $newregion = optional_param('bui_newregion', '', PARAM_ALPHANUMEXT
);
1824 $newweight = optional_param('bui_newweight', null, PARAM_FLOAT
);
1825 if (!$newregion ||
is_null($newweight)) {
1826 // Don't have a valid target position yet, must be just starting the move.
1827 $this->movingblock
= $blockid;
1828 $this->page
->ensure_param_not_in_url('bui_moveid');
1832 if (!$this->is_known_region($newregion)) {
1833 throw new moodle_exception('unknownblockregion', '', $this->page
->url
, $newregion);
1836 // Move this block. This may involve moving other nearby blocks.
1837 $blocks = $this->birecordsbyregion
[$newregion];
1839 $maxweight = self
::MAX_WEIGHT
;
1840 $minweight = -self
::MAX_WEIGHT
;
1842 // Initialise the used weights and spareweights array with the default values
1843 $spareweights = array();
1844 $usedweights = array();
1845 for ($i = $minweight; $i <= $maxweight; $i++
) {
1846 $spareweights[$i] = $i;
1847 $usedweights[$i] = array();
1850 // Check each block and sort out where we have used weights
1851 foreach ($blocks as $bi) {
1852 if ($bi->weight
> $maxweight) {
1853 // If this statement is true then the blocks weight is more than the
1854 // current maximum. To ensure that we can get the best block position
1855 // we will initialise elements within the usedweights and spareweights
1856 // arrays between the blocks weight (which will then be the new max) and
1858 $parseweight = $bi->weight
;
1859 while (!array_key_exists($parseweight, $usedweights)) {
1860 $usedweights[$parseweight] = array();
1861 $spareweights[$parseweight] = $parseweight;
1864 $maxweight = $bi->weight
;
1865 } else if ($bi->weight
< $minweight) {
1866 // As above except this time the blocks weight is LESS than the
1867 // the current minimum, so we will initialise the array from the
1868 // blocks weight (new minimum) to the current minimum
1869 $parseweight = $bi->weight
;
1870 while (!array_key_exists($parseweight, $usedweights)) {
1871 $usedweights[$parseweight] = array();
1872 $spareweights[$parseweight] = $parseweight;
1875 $minweight = $bi->weight
;
1877 if ($bi->id
!= $block->instance
->id
) {
1878 unset($spareweights[$bi->weight
]);
1879 $usedweights[$bi->weight
][] = $bi->id
;
1883 // First we find the nearest gap in the list of weights.
1884 $bestdistance = max(abs($newweight - self
::MAX_WEIGHT
), abs($newweight + self
::MAX_WEIGHT
)) +
1;
1886 foreach ($spareweights as $spareweight) {
1887 if (abs($newweight - $spareweight) < $bestdistance) {
1888 $bestdistance = abs($newweight - $spareweight);
1889 $bestgap = $spareweight;
1893 // If there is no gap, we have to go outside -self::MAX_WEIGHT .. self::MAX_WEIGHT.
1894 if (is_null($bestgap)) {
1895 $bestgap = self
::MAX_WEIGHT +
1;
1896 while (!empty($usedweights[$bestgap])) {
1901 // Now we know the gap we are aiming for, so move all the blocks along.
1902 if ($bestgap < $newweight) {
1903 $newweight = floor($newweight);
1904 for ($weight = $bestgap +
1; $weight <= $newweight; $weight++
) {
1905 if (array_key_exists($weight, $usedweights)) {
1906 foreach ($usedweights[$weight] as $biid) {
1907 $this->reposition_block($biid, $newregion, $weight - 1);
1911 $this->reposition_block($block->instance
->id
, $newregion, $newweight);
1913 $newweight = ceil($newweight);
1914 for ($weight = $bestgap - 1; $weight >= $newweight; $weight--) {
1915 if (array_key_exists($weight, $usedweights)) {
1916 foreach ($usedweights[$weight] as $biid) {
1917 $this->reposition_block($biid, $newregion, $weight +
1);
1921 $this->reposition_block($block->instance
->id
, $newregion, $newweight);
1924 $this->page
->ensure_param_not_in_url('bui_moveid');
1925 $this->page
->ensure_param_not_in_url('bui_newregion');
1926 $this->page
->ensure_param_not_in_url('bui_newweight');
1931 * Turns the display of normal blocks either on or off.
1933 * @param bool $setting
1935 public function show_only_fake_blocks($setting = true) {
1936 $this->fakeblocksonly
= $setting;
1940 /// Helper functions for working with block classes ============================
1943 * Call a class method (one that does not require a block instance) on a block class.
1945 * @param string $blockname the name of the block.
1946 * @param string $method the method name.
1947 * @param array $param parameters to pass to the method.
1948 * @return mixed whatever the method returns.
1950 function block_method_result($blockname, $method, $param = NULL) {
1951 if(!block_load_class($blockname)) {
1954 return call_user_func(array('block_'.$blockname, $method), $param);
1958 * Returns a new instance of the specified block instance id.
1960 * @param int $blockinstanceid
1961 * @return block_base the requested block instance.
1963 function block_instance_by_id($blockinstanceid) {
1966 $blockinstance = $DB->get_record('block_instances', ['id' => $blockinstanceid]);
1967 $instance = block_instance($blockinstance->blockname
, $blockinstance);
1972 * Creates a new instance of the specified block class.
1974 * @param string $blockname the name of the block.
1975 * @param $instance block_instances DB table row (optional).
1976 * @param moodle_page $page the page this block is appearing on.
1977 * @return block_base the requested block instance.
1979 function block_instance($blockname, $instance = NULL, $page = NULL) {
1980 if(!block_load_class($blockname)) {
1983 $classname = 'block_'.$blockname;
1984 $retval = new $classname;
1985 if($instance !== NULL) {
1986 if (is_null($page)) {
1990 $retval->_load_instance($instance, $page);
1996 * Load the block class for a particular type of block.
1998 * @param string $blockname the name of the block.
1999 * @return boolean success or failure.
2001 function block_load_class($blockname) {
2004 if(empty($blockname)) {
2008 $classname = 'block_'.$blockname;
2010 if(class_exists($classname)) {
2014 $blockpath = $CFG->dirroot
.'/blocks/'.$blockname.'/block_'.$blockname.'.php';
2016 if (file_exists($blockpath)) {
2017 require_once($CFG->dirroot
.'/blocks/moodleblock.class.php');
2018 include_once($blockpath);
2020 //debugging("$blockname code does not exist in $blockpath", DEBUG_DEVELOPER);
2024 return class_exists($classname);
2028 * Given a specific page type, return all the page type patterns that might
2031 * @param string $pagetype for example 'course-view-weeks' or 'mod-quiz-view'.
2032 * @return array an array of all the page type patterns that might match this page type.
2034 function matching_page_type_patterns($pagetype) {
2035 $patterns = array($pagetype);
2036 $bits = explode('-', $pagetype);
2037 if (count($bits) == 3 && $bits[0] == 'mod') {
2038 if ($bits[2] == 'view') {
2039 $patterns[] = 'mod-*-view';
2040 } else if ($bits[2] == 'index') {
2041 $patterns[] = 'mod-*-index';
2044 while (count($bits) > 0) {
2045 $patterns[] = implode('-', $bits) . '-*';
2053 * Give an specific pattern, return all the page type patterns that would also match it.
2055 * @param string $pattern the pattern, e.g. 'mod-forum-*' or 'mod-quiz-view'.
2056 * @return array of all the page type patterns matching.
2058 function matching_page_type_patterns_from_pattern($pattern) {
2059 $patterns = array($pattern);
2060 if ($pattern === '*') {
2064 // Only keep the part before the star because we will append -* to all the bits.
2065 $star = strpos($pattern, '-*');
2066 if ($star !== false) {
2067 $pattern = substr($pattern, 0, $star);
2070 $patterns = array_merge($patterns, matching_page_type_patterns($pattern));
2071 $patterns = array_unique($patterns);
2077 * Given a specific page type, parent context and currect context, return all the page type patterns
2078 * that might be used by this block.
2080 * @param string $pagetype for example 'course-view-weeks' or 'mod-quiz-view'.
2081 * @param stdClass $parentcontext Block's parent context
2082 * @param stdClass $currentcontext Current context of block
2083 * @return array an array of all the page type patterns that might match this page type.
2085 function generate_page_type_patterns($pagetype, $parentcontext = null, $currentcontext = null) {
2086 global $CFG; // Required for includes bellow.
2088 $bits = explode('-', $pagetype);
2090 $core = core_component
::get_core_subsystems();
2091 $plugins = core_component
::get_plugin_types();
2093 //progressively strip pieces off the page type looking for a match
2094 $componentarray = null;
2095 for ($i = count($bits); $i > 0; $i--) {
2096 $possiblecomponentarray = array_slice($bits, 0, $i);
2097 $possiblecomponent = implode('', $possiblecomponentarray);
2099 // Check to see if the component is a core component
2100 if (array_key_exists($possiblecomponent, $core) && !empty($core[$possiblecomponent])) {
2101 $libfile = $core[$possiblecomponent].'/lib.php';
2102 if (file_exists($libfile)) {
2103 require_once($libfile);
2104 $function = $possiblecomponent.'_page_type_list';
2105 if (function_exists($function)) {
2106 if ($patterns = $function($pagetype, $parentcontext, $currentcontext)) {
2113 //check the plugin directory and look for a callback
2114 if (array_key_exists($possiblecomponent, $plugins) && !empty($plugins[$possiblecomponent])) {
2116 //We've found a plugin type. Look for a plugin name by getting the next section of page type
2117 if (count($bits) > $i) {
2118 $pluginname = $bits[$i];
2119 $directory = core_component
::get_plugin_directory($possiblecomponent, $pluginname);
2120 if (!empty($directory)){
2121 $libfile = $directory.'/lib.php';
2122 if (file_exists($libfile)) {
2123 require_once($libfile);
2124 $function = $possiblecomponent.'_'.$pluginname.'_page_type_list';
2125 if (!function_exists($function)) {
2126 $function = $pluginname.'_page_type_list';
2128 if (function_exists($function)) {
2129 if ($patterns = $function($pagetype, $parentcontext, $currentcontext)) {
2137 //we'll only get to here if we still don't have any patterns
2138 //the plugin type may have a callback
2139 $directory = $plugins[$possiblecomponent];
2140 $libfile = $directory.'/lib.php';
2141 if (file_exists($libfile)) {
2142 require_once($libfile);
2143 $function = $possiblecomponent.'_page_type_list';
2144 if (function_exists($function)) {
2145 if ($patterns = $function($pagetype, $parentcontext, $currentcontext)) {
2153 if (empty($patterns)) {
2154 $patterns = default_page_type_list($pagetype, $parentcontext, $currentcontext);
2157 // Ensure that the * pattern is always available if editing block 'at distance', so
2158 // we always can 'bring back' it to the original context. MDL-30340
2159 if ((!isset($currentcontext) or !isset($parentcontext) or $currentcontext->id
!= $parentcontext->id
) && !isset($patterns['*'])) {
2160 // TODO: We could change the string here, showing its 'bring back' meaning
2161 $patterns['*'] = get_string('page-x', 'pagetype');
2168 * Generates a default page type list when a more appropriate callback cannot be decided upon.
2170 * @param string $pagetype
2171 * @param stdClass $parentcontext
2172 * @param stdClass $currentcontext
2175 function default_page_type_list($pagetype, $parentcontext = null, $currentcontext = null) {
2176 // Generate page type patterns based on current page type if
2177 // callbacks haven't been defined
2178 $patterns = array($pagetype => $pagetype);
2179 $bits = explode('-', $pagetype);
2180 while (count($bits) > 0) {
2181 $pattern = implode('-', $bits) . '-*';
2182 $pagetypestringname = 'page-'.str_replace('*', 'x', $pattern);
2183 // guessing page type description
2184 if (get_string_manager()->string_exists($pagetypestringname, 'pagetype')) {
2185 $patterns[$pattern] = get_string($pagetypestringname, 'pagetype');
2187 $patterns[$pattern] = $pattern;
2191 $patterns['*'] = get_string('page-x', 'pagetype');
2196 * Generates the page type list for the my moodle page
2198 * @param string $pagetype
2199 * @param stdClass $parentcontext
2200 * @param stdClass $currentcontext
2203 function my_page_type_list($pagetype, $parentcontext = null, $currentcontext = null) {
2204 return array('my-index' => get_string('page-my-index', 'pagetype'));
2208 * Generates the page type list for a module by either locating and using the modules callback
2209 * or by generating a default list.
2211 * @param string $pagetype
2212 * @param stdClass $parentcontext
2213 * @param stdClass $currentcontext
2216 function mod_page_type_list($pagetype, $parentcontext = null, $currentcontext = null) {
2217 $patterns = plugin_page_type_list($pagetype, $parentcontext, $currentcontext);
2218 if (empty($patterns)) {
2219 // if modules don't have callbacks
2220 // generate two default page type patterns for modules only
2221 $bits = explode('-', $pagetype);
2222 $patterns = array($pagetype => $pagetype);
2223 if ($bits[2] == 'view') {
2224 $patterns['mod-*-view'] = get_string('page-mod-x-view', 'pagetype');
2225 } else if ($bits[2] == 'index') {
2226 $patterns['mod-*-index'] = get_string('page-mod-x-index', 'pagetype');
2231 /// Functions update the blocks if required by the request parameters ==========
2234 * Return a {@link block_contents} representing the add a new block UI, if
2235 * this user is allowed to see it.
2237 * @return block_contents an appropriate block_contents, or null if the user
2238 * cannot add any blocks here.
2240 function block_add_block_ui($page, $output) {
2241 global $CFG, $OUTPUT;
2242 if (!$page->user_is_editing() ||
!$page->user_can_edit_blocks()) {
2246 $bc = new block_contents();
2247 $bc->title
= get_string('addblock');
2248 $bc->add_class('block_adminblock');
2249 $bc->attributes
['data-block'] = 'adminblock';
2251 $missingblocks = $page->blocks
->get_addable_blocks();
2252 if (empty($missingblocks)) {
2253 $bc->content
= get_string('noblockstoaddhere');
2258 foreach ($missingblocks as $block) {
2259 $menu[$block->name
] = $block->title
;
2262 $actionurl = new moodle_url($page->url
, array('sesskey'=>sesskey()));
2263 $select = new single_select($actionurl, 'bui_addblock', $menu, null, array(''=>get_string('adddots')), 'add_block');
2264 $select->set_label(get_string('addblock'), array('class'=>'accesshide'));
2265 $bc->content
= $OUTPUT->render($select);
2270 * Actually delete from the database any blocks that are currently on this page,
2271 * but which should not be there according to blocks_name_allowed_in_format.
2273 * @todo Write/Fix this function. Currently returns immediately
2276 function blocks_remove_inappropriate($course) {
2280 $blockmanager = blocks_get_by_page($page);
2282 if (empty($blockmanager)) {
2286 if (($pageformat = $page->pagetype) == NULL) {
2290 foreach($blockmanager as $region) {
2291 foreach($region as $instance) {
2292 $block = blocks_get_record($instance->blockid);
2293 if(!blocks_name_allowed_in_format($block->name, $pageformat)) {
2294 blocks_delete_instance($instance->instance);
2301 * Check that a given name is in a permittable format
2303 * @param string $name
2304 * @param string $pageformat
2307 function blocks_name_allowed_in_format($name, $pageformat) {
2310 if (!$bi = block_instance($name)) {
2314 $formats = $bi->applicable_formats();
2318 foreach ($formats as $format => $allowed) {
2319 $formatregex = '/^'.str_replace('*', '[^-]*', $format).'.*$/';
2320 $depth = substr_count($format, '-');
2321 if (preg_match($formatregex, $pageformat) && $depth > $maxdepth) {
2326 if ($accept === NULL) {
2327 $accept = !empty($formats['all']);
2333 * Delete a block, and associated data.
2335 * @param object $instance a row from the block_instances table
2336 * @param bool $nolongerused legacy parameter. Not used, but kept for backwards compatibility.
2337 * @param bool $skipblockstables for internal use only. Makes @see blocks_delete_all_for_context() more efficient.
2339 function blocks_delete_instance($instance, $nolongerused = false, $skipblockstables = false) {
2342 // Allow plugins to use this block before we completely delete it.
2343 if ($pluginsfunction = get_plugins_with_function('pre_block_delete')) {
2344 foreach ($pluginsfunction as $plugintype => $plugins) {
2345 foreach ($plugins as $pluginfunction) {
2346 $pluginfunction($instance);
2351 if ($block = block_instance($instance->blockname
, $instance)) {
2352 $block->instance_delete();
2354 context_helper
::delete_instance(CONTEXT_BLOCK
, $instance->id
);
2356 if (!$skipblockstables) {
2357 $DB->delete_records('block_positions', array('blockinstanceid' => $instance->id
));
2358 $DB->delete_records('block_instances', array('id' => $instance->id
));
2359 $DB->delete_records_list('user_preferences', 'name', array('block'.$instance->id
.'hidden','docked_block_instance_'.$instance->id
));
2364 * Delete multiple blocks at once.
2366 * @param array $instanceids A list of block instance ID.
2368 function blocks_delete_instances($instanceids) {
2372 $count = count($instanceids);
2373 $chunks = [$instanceids];
2374 if ($count > $limit) {
2375 $chunks = array_chunk($instanceids, $limit);
2378 // Perform deletion for each chunk.
2379 foreach ($chunks as $chunk) {
2380 $instances = $DB->get_recordset_list('block_instances', 'id', $chunk);
2381 foreach ($instances as $instance) {
2382 blocks_delete_instance($instance, false, true);
2384 $instances->close();
2386 $DB->delete_records_list('block_positions', 'blockinstanceid', $chunk);
2387 $DB->delete_records_list('block_instances', 'id', $chunk);
2389 $preferences = array();
2390 foreach ($chunk as $instanceid) {
2391 $preferences[] = 'block' . $instanceid . 'hidden';
2392 $preferences[] = 'docked_block_instance_' . $instanceid;
2394 $DB->delete_records_list('user_preferences', 'name', $preferences);
2399 * Delete all the blocks that belong to a particular context.
2401 * @param int $contextid the context id.
2403 function blocks_delete_all_for_context($contextid) {
2405 $instances = $DB->get_recordset('block_instances', array('parentcontextid' => $contextid));
2406 foreach ($instances as $instance) {
2407 blocks_delete_instance($instance, true);
2409 $instances->close();
2410 $DB->delete_records('block_instances', array('parentcontextid' => $contextid));
2411 $DB->delete_records('block_positions', array('contextid' => $contextid));
2415 * Set a block to be visible or hidden on a particular page.
2417 * @param object $instance a row from the block_instances, preferably LEFT JOINed with the
2418 * block_positions table as return by block_manager.
2419 * @param moodle_page $page the back to set the visibility with respect to.
2420 * @param integer $newvisibility 1 for visible, 0 for hidden.
2422 function blocks_set_visibility($instance, $page, $newvisibility) {
2424 if (!empty($instance->blockpositionid
)) {
2425 // Already have local information on this page.
2426 $DB->set_field('block_positions', 'visible', $newvisibility, array('id' => $instance->blockpositionid
));
2430 // Create a new block_positions record.
2432 $bp->blockinstanceid
= $instance->id
;
2433 $bp->contextid
= $page->context
->id
;
2434 $bp->pagetype
= $page->pagetype
;
2435 if ($page->subpage
) {
2436 $bp->subpage
= $page->subpage
;
2438 $bp->visible
= $newvisibility;
2439 $bp->region
= $instance->defaultregion
;
2440 $bp->weight
= $instance->defaultweight
;
2441 $DB->insert_record('block_positions', $bp);
2445 * Get the block record for a particular blockid - that is, a particular type os block.
2447 * @param $int blockid block type id. If null, an array of all block types is returned.
2448 * @param bool $notusedanymore No longer used.
2449 * @return array|object row from block table, or all rows.
2451 function blocks_get_record($blockid = NULL, $notusedanymore = false) {
2453 $blocks = $PAGE->blocks
->get_installed_blocks();
2454 if ($blockid === NULL) {
2456 } else if (isset($blocks[$blockid])) {
2457 return $blocks[$blockid];
2464 * Find a given block by its blockid within a provide array
2466 * @param int $blockid
2467 * @param array $blocksarray
2468 * @return bool|object Instance if found else false
2470 function blocks_find_block($blockid, $blocksarray) {
2471 if (empty($blocksarray)) {
2474 foreach($blocksarray as $blockgroup) {
2475 if (empty($blockgroup)) {
2478 foreach($blockgroup as $instance) {
2479 if($instance->blockid
== $blockid) {
2487 // Functions for programatically adding default blocks to pages ================
2490 * Parse a list of default blocks. See config-dist for a description of the format.
2492 * @param string $blocksstr Determines the starting point that the blocks are added in the region.
2493 * @return array the parsed list of default blocks
2495 function blocks_parse_default_blocks_list($blocksstr) {
2497 $bits = explode(':', $blocksstr);
2498 if (!empty($bits)) {
2499 $leftbits = trim(array_shift($bits));
2500 if ($leftbits != '') {
2501 $blocks[BLOCK_POS_LEFT
] = explode(',', $leftbits);
2504 if (!empty($bits)) {
2505 $rightbits = trim(array_shift($bits));
2506 if ($rightbits != '') {
2507 $blocks[BLOCK_POS_RIGHT
] = explode(',', $rightbits);
2514 * @return array the blocks that should be added to the site course by default.
2516 function blocks_get_default_site_course_blocks() {
2519 if (isset($CFG->defaultblocks_site
)) {
2520 return blocks_parse_default_blocks_list($CFG->defaultblocks_site
);
2523 BLOCK_POS_LEFT
=> array(),
2524 BLOCK_POS_RIGHT
=> array()
2530 * Add the default blocks to a course.
2532 * @param object $course a course object.
2534 function blocks_add_default_course_blocks($course) {
2537 if (isset($CFG->defaultblocks_override
)) {
2538 $blocknames = blocks_parse_default_blocks_list($CFG->defaultblocks_override
);
2540 } else if ($course->id
== SITEID
) {
2541 $blocknames = blocks_get_default_site_course_blocks();
2543 } else if (isset($CFG->{'defaultblocks_' . $course->format
})) {
2544 $blocknames = blocks_parse_default_blocks_list($CFG->{'defaultblocks_' . $course->format
});
2547 require_once($CFG->dirroot
. '/course/lib.php');
2548 $blocknames = course_get_format($course)->get_default_blocks();
2552 if ($course->id
== SITEID
) {
2553 $pagetypepattern = 'site-index';
2555 $pagetypepattern = 'course-view-*';
2557 $page = new moodle_page();
2558 $page->set_course($course);
2559 $page->blocks
->add_blocks($blocknames, $pagetypepattern);
2563 * Add the default system-context blocks. E.g. the admin tree.
2565 function blocks_add_default_system_blocks() {
2568 $page = new moodle_page();
2569 $page->set_context(context_system
::instance());
2570 // We don't add blocks required by the theme, they will be auto-created.
2571 $page->blocks
->add_blocks(array(BLOCK_POS_LEFT
=> array('admin_bookmarks')), 'admin-*', null, null, 2);
2573 if ($defaultmypage = $DB->get_record('my_pages', array('userid' => null, 'name' => '__default', 'private' => 1))) {
2574 $subpagepattern = $defaultmypage->id
;
2576 $subpagepattern = null;
2579 $newblocks = array('private_files', 'online_users', 'badges', 'calendar_month', 'calendar_upcoming');
2580 $newcontent = array('lp', 'myoverview');
2581 $page->blocks
->add_blocks(array(BLOCK_POS_RIGHT
=> $newblocks, 'content' => $newcontent), 'my-index', $subpagepattern);