lib/blocklib.php

   1 <?php
   2
   3 // This file is part of Moodle - http://moodle.org/
   4 //
   5 // Moodle is free software: you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation, either version 3 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // Moodle is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License
  16 // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  17
  18 /**
  19  * 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  */
  28
  29 defined('MOODLE_INTERNAL') || die();
  30
  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 /**#@-*/
  40
  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 /**#@-*/
  47
  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 /**#@-*/
  55
  56 define('BUI_CONTEXTS_FRONTPAGE_ONLY', 0);
  57 define('BUI_CONTEXTS_FRONTPAGE_SUBS', 1);
  58 define('BUI_CONTEXTS_ENTIRE_SITE', 2);
  59
  60 define('BUI_CONTEXTS_CURRENT', 0);
  61 define('BUI_CONTEXTS_CURRENT_SUBS', 1);
  62
  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 }
  84
  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;
 100
 101 /// Field declarations =========================================================
 102
 103     /**
 104      * the moodle_page we are managing blocks for.
 105      * @var moodle_page
 106      */
 107     protected $page;
 108
 109     /** @var array region name => 1.*/
 110     protected $regions = array();
 111
 112     /** @var string the region where new blocks are added.*/
 113     protected $defaultregion = null;
 114
 115     /** @var array will be $DB->get_records('blocks') */
 116     protected $allblocks = null;
 117
 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;
 124
 125     /**
 126      * Will be an array region-name => array(db rows loaded in load_blocks);
 127      * @var array
 128      */
 129     protected $birecordsbyregion = null;
 130
 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();
 137
 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();
 144
 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();
 151
 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;
 162
 163     /**
 164      * Show only fake blocks
 165      */
 166     protected $fakeblocksonly = false;
 167
 168 /// Constructor ================================================================
 169
 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     }
 179
 180 /// Getter methods =============================================================
 181
 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     }
 193
 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     }
 206
 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();
 214
 215         if (!is_null($this->addableblocks)) {
 216             return $this->addableblocks;
 217         }
 218
 219         // Lazy load.
 220         $this->addableblocks = array();
 221
 222         $allblocks = blocks_get_record();
 223         if (empty($allblocks)) {
 224             return $this->addableblocks;
 225         }
 226
 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         }
 240
 241         return $this->addableblocks;
 242     }
 243
 244     /**
 245      * Given a block name, find out of any of them are currently present in the page
 246
 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         }
 254
 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     }
 267
 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     }
 284
 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     }
 294
 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     }
 306
 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     }
 318
 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     }
 330
 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 core_renderer $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) {
 348
 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     }
 363
 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     }
 376
 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;
 382
 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     }
 391
 392 /// Setter methods =============================================================
 393
 394     /**
 395      * Add a region to a page
 396      *
 397      * @param string $region add a named region where blocks may appear on the current page.
 398      *      This is an internal name, like 'side-pre', not a string to display in the UI.
 399      * @param bool $custom True if this is a custom block region, being added by the page rather than the theme layout.
 400      */
 401     public function add_region($region, $custom = true) {
 402         global $SESSION;
 403         $this->check_not_yet_loaded();
 404         if ($custom) {
 405             if (array_key_exists($region, $this->regions)) {
 406                 // This here is EXACTLY why we should not be adding block regions into a page. It should
 407                 // ALWAYS be done in a theme layout.
 408                 debugging('A custom region conflicts with a block region in the theme.', DEBUG_DEVELOPER);
 409             }
 410             // We need to register this custom region against the page type being used.
 411             // This allows us to check, when performing block actions, that unrecognised regions can be worked with.
 412             $type = $this->page->pagetype;
 413             if (!isset($SESSION->custom_block_regions)) {
 414                 $SESSION->custom_block_regions = array($type => array($region));
 415             } else if (!isset($SESSION->custom_block_regions[$type])) {
 416                 $SESSION->custom_block_regions[$type] = array($region);
 417             } else if (!in_array($region, $SESSION->custom_block_regions[$type])) {
 418                 $SESSION->custom_block_regions[$type][] = $region;
 419             }
 420         }
 421         $this->regions[$region] = 1;
 422     }
 423
 424     /**
 425      * Add an array of regions
 426      * @see add_region()
 427      *
 428      * @param array $regions this utility method calls add_region for each array element.
 429      */
 430     public function add_regions($regions, $custom = true) {
 431         foreach ($regions as $region) {
 432             $this->add_region($region, $custom);
 433         }
 434     }
 435
 436     /**
 437      * Finds custom block regions associated with a page type and registers them with this block manager.
 438      *
 439      * @param string $pagetype
 440      */
 441     public function add_custom_regions_for_pagetype($pagetype) {
 442         global $SESSION;
 443         if (isset($SESSION->custom_block_regions[$pagetype])) {
 444             foreach ($SESSION->custom_block_regions[$pagetype] as $customregion) {
 445                 $this->add_region($customregion, false);
 446             }
 447         }
 448     }
 449
 450     /**
 451      * Set the default region for new blocks on the page
 452      *
 453      * @param string $defaultregion the internal names of the region where new
 454      * blocks should be added by default, and where any blocks from an
 455      * unrecognised region are shown.
 456      */
 457     public function set_default_region($defaultregion) {
 458         $this->check_not_yet_loaded();
 459         if ($defaultregion) {
 460             $this->check_region_is_known($defaultregion);
 461         }
 462         $this->defaultregion = $defaultregion;
 463     }
 464
 465     /**
 466      * Add something that looks like a block, but which isn't an actual block_instance,
 467      * to this page.
 468      *
 469      * @param block_contents $bc the content of the block-like thing.
 470      * @param string $region a block region that exists on this page.
 471      */
 472     public function add_fake_block($bc, $region) {
 473         $this->page->initialise_theme_and_output();
 474         if (!$this->is_known_region($region)) {
 475             $region = $this->get_default_region();
 476         }
 477         if (array_key_exists($region, $this->visibleblockcontent)) {
 478             throw new coding_exception('block_manager has already prepared the blocks in region ' .
 479                     $region . 'for output. It is too late to add a fake block.');
 480         }
 481         if (!isset($bc->attributes['data-block'])) {
 482             $bc->attributes['data-block'] = '_fake';
 483         }
 484         $bc->attributes['class'] .= ' block_fake';
 485         $this->extracontent[$region][] = $bc;
 486     }
 487
 488     /**
 489      * When the block_manager class was created, the {@link add_fake_block()}
 490      * was called add_pretend_block, which is inconsisted with
 491      * {@link show_only_fake_blocks()}. To fix this inconsistency, this method
 492      * was renamed to add_fake_block. Please update your code.
 493      * @param block_contents $bc the content of the block-like thing.
 494      * @param string $region a block region that exists on this page.
 495      */
 496     public function add_pretend_block($bc, $region) {
 497         debugging(DEBUG_DEVELOPER, 'add_pretend_block has been renamed to add_fake_block. Please rename the method call in your code.');
 498         $this->add_fake_block($bc, $region);
 499     }
 500
 501     /**
 502      * Checks to see whether all of the blocks within the given region are docked
 503      *
 504      * @see region_uses_dock
 505      * @param string $region
 506      * @return bool True if all of the blocks within that region are docked
 507      */
 508     public function region_completely_docked($region, $output) {
 509         global $CFG;
 510         // If theme doesn't allow docking or allowblockstodock is not set, then return.
 511         if (!$this->page->theme->enable_dock || empty($CFG->allowblockstodock)) {
 512             return false;
 513         }
 514
 515         // Do not dock the region when the user attemps to move a block.
 516         if ($this->movingblock) {
 517             return false;
 518         }
 519
 520         // Block regions should not be docked during editing when all the blocks are hidden.
 521         if ($this->page->user_is_editing() && $this->page->user_can_edit_blocks()) {
 522             return false;
 523         }
 524
 525         $this->check_is_loaded();
 526         $this->ensure_content_created($region, $output);
 527         if (!$this->region_has_content($region, $output)) {
 528             // If the region has no content then nothing is docked at all of course.
 529             return false;
 530         }
 531         foreach ($this->visibleblockcontent[$region] as $instance) {
 532             if (!empty($instance->content) && !get_user_preferences('docked_block_instance_'.$instance->blockinstanceid, 0)) {
 533                 return false;
 534             }
 535         }
 536         return true;
 537     }
 538
 539     /**
 540      * Checks to see whether any of the blocks within the given regions are docked
 541      *
 542      * @see region_completely_docked
 543      * @param array|string $regions array of regions (or single region)
 544      * @return bool True if any of the blocks within that region are docked
 545      */
 546     public function region_uses_dock($regions, $output) {
 547         if (!$this->page->theme->enable_dock) {
 548             return false;
 549         }
 550         $this->check_is_loaded();
 551         foreach((array)$regions as $region) {
 552             $this->ensure_content_created($region, $output);
 553             foreach($this->visibleblockcontent[$region] as $instance) {
 554                 if(!empty($instance->content) && get_user_preferences('docked_block_instance_'.$instance->blockinstanceid, 0)) {
 555                     return true;
 556                 }
 557             }
 558         }
 559         return false;
 560     }
 561
 562 /// Actions ====================================================================
 563
 564     /**
 565      * This method actually loads the blocks for our page from the database.
 566      *
 567      * @param boolean|null $includeinvisible
 568      *      null (default) - load hidden blocks if $this->page->user_is_editing();
 569      *      true - load hidden blocks.
 570      *      false - don't load hidden blocks.
 571      */
 572     public function load_blocks($includeinvisible = null) {
 573         global $DB, $CFG;
 574
 575         if (!is_null($this->birecordsbyregion)) {
 576             // Already done.
 577             return;
 578         }
 579
 580         if ($CFG->version < 2009050619) {
 581             // Upgrade/install not complete. Don't try too show any blocks.
 582             $this->birecordsbyregion = array();
 583             return;
 584         }
 585
 586         // Ensure we have been initialised.
 587         if (is_null($this->defaultregion)) {
 588             $this->page->initialise_theme_and_output();
 589             // If there are still no block regions, then there are no blocks on this page.
 590             if (empty($this->regions)) {
 591                 $this->birecordsbyregion = array();
 592                 return;
 593             }
 594         }
 595
 596         // Check if we need to load normal blocks
 597         if ($this->fakeblocksonly) {
 598             $this->birecordsbyregion = $this->prepare_per_region_arrays();
 599             return;
 600         }
 601
 602         if (is_null($includeinvisible)) {
 603             $includeinvisible = $this->page->user_is_editing();
 604         }
 605         if ($includeinvisible) {
 606             $visiblecheck = '';
 607         } else {
 608             $visiblecheck = 'AND (bp.visible = 1 OR bp.visible IS NULL)';
 609         }
 610
 611         $context = $this->page->context;
 612         $contexttest = 'bi.parentcontextid = :contextid2';
 613         $parentcontextparams = array();
 614         $parentcontextids = $context->get_parent_context_ids();
 615         if ($parentcontextids) {
 616             list($parentcontexttest, $parentcontextparams) =
 617                     $DB->get_in_or_equal($parentcontextids, SQL_PARAMS_NAMED, 'parentcontext');
 618             $contexttest = "($contexttest OR (bi.showinsubcontexts = 1 AND bi.parentcontextid $parentcontexttest))";
 619         }
 620
 621         $pagetypepatterns = matching_page_type_patterns($this->page->pagetype);
 622         list($pagetypepatterntest, $pagetypepatternparams) =
 623                 $DB->get_in_or_equal($pagetypepatterns, SQL_PARAMS_NAMED, 'pagetypepatterntest');
 624
 625         $ccselect = ', ' . context_helper::get_preload_record_columns_sql('ctx');
 626         $ccjoin = "LEFT JOIN {context} ctx ON (ctx.instanceid = bi.id AND ctx.contextlevel = :contextlevel)";
 627
 628         $params = array(
 629             'contextlevel' => CONTEXT_BLOCK,
 630             'subpage1' => $this->page->subpage,
 631             'subpage2' => $this->page->subpage,
 632             'contextid1' => $context->id,
 633             'contextid2' => $context->id,
 634             'pagetype' => $this->page->pagetype,
 635         );
 636         if ($this->page->subpage === '') {
 637             $params['subpage1'] = '';
 638             $params['subpage2'] = '';
 639         }
 640         $sql = "SELECT
 641                     bi.id,
 642                     bp.id AS blockpositionid,
 643                     bi.blockname,
 644                     bi.parentcontextid,
 645                     bi.showinsubcontexts,
 646                     bi.pagetypepattern,
 647                     bi.subpagepattern,
 648                     bi.defaultregion,
 649                     bi.defaultweight,
 650                     COALESCE(bp.visible, 1) AS visible,
 651                     COALESCE(bp.region, bi.defaultregion) AS region,
 652                     COALESCE(bp.weight, bi.defaultweight) AS weight,
 653                     bi.configdata
 654                     $ccselect
 655
 656                 FROM {block_instances} bi
 657                 JOIN {block} b ON bi.blockname = b.name
 658                 LEFT JOIN {block_positions} bp ON bp.blockinstanceid = bi.id
 659                                                   AND bp.contextid = :contextid1
 660                                                   AND bp.pagetype = :pagetype
 661                                                   AND bp.subpage = :subpage1
 662                 $ccjoin
 663
 664                 WHERE
 665                 $contexttest
 666                 AND bi.pagetypepattern $pagetypepatterntest
 667                 AND (bi.subpagepattern IS NULL OR bi.subpagepattern = :subpage2)
 668                 $visiblecheck
 669                 AND b.visible = 1
 670
 671                 ORDER BY
 672                     COALESCE(bp.region, bi.defaultregion),
 673                     COALESCE(bp.weight, bi.defaultweight),
 674                     bi.id";
 675         $blockinstances = $DB->get_recordset_sql($sql, $params + $parentcontextparams + $pagetypepatternparams);
 676
 677         $this->birecordsbyregion = $this->prepare_per_region_arrays();
 678         $unknown = array();
 679         foreach ($blockinstances as $bi) {
 680             context_helper::preload_from_record($bi);
 681             if ($this->is_known_region($bi->region)) {
 682                 $this->birecordsbyregion[$bi->region][] = $bi;
 683             } else {
 684                 $unknown[] = $bi;
 685             }
 686         }
 687
 688         // Pages don't necessarily have a defaultregion. The  one time this can
 689         // happen is when there are no theme block regions, but the script itself
 690         // has a block region in the main content area.
 691         if (!empty($this->defaultregion)) {
 692             $this->birecordsbyregion[$this->defaultregion] =
 693                     array_merge($this->birecordsbyregion[$this->defaultregion], $unknown);
 694         }
 695     }
 696
 697     /**
 698      * Add a block to the current page, or related pages. The block is added to
 699      * context $this->page->contextid. If $pagetypepattern $subpagepattern
 700      *
 701      * @param string $blockname The type of block to add.
 702      * @param string $region the block region on this page to add the block to.
 703      * @param integer $weight determines the order where this block appears in the region.
 704      * @param boolean $showinsubcontexts whether this block appears in subcontexts, or just the current context.
 705      * @param string|null $pagetypepattern which page types this block should appear on. Defaults to just the current page type.
 706      * @param string|null $subpagepattern which subpage this block should appear on. NULL = any (the default), otherwise only the specified subpage.
 707      */
 708     public function add_block($blockname, $region, $weight, $showinsubcontexts, $pagetypepattern = NULL, $subpagepattern = NULL) {
 709         global $DB;
 710         // Allow invisible blocks because this is used when adding default page blocks, which
 711         // might include invisible ones if the user makes some default blocks invisible
 712         $this->check_known_block_type($blockname, true);
 713         $this->check_region_is_known($region);
 714
 715         if (empty($pagetypepattern)) {
 716             $pagetypepattern = $this->page->pagetype;
 717         }
 718
 719         $blockinstance = new stdClass;
 720         $blockinstance->blockname = $blockname;
 721         $blockinstance->parentcontextid = $this->page->context->id;
 722         $blockinstance->showinsubcontexts = !empty($showinsubcontexts);
 723         $blockinstance->pagetypepattern = $pagetypepattern;
 724         $blockinstance->subpagepattern = $subpagepattern;
 725         $blockinstance->defaultregion = $region;
 726         $blockinstance->defaultweight = $weight;
 727         $blockinstance->configdata = '';
 728         $blockinstance->id = $DB->insert_record('block_instances', $blockinstance);
 729
 730         // Ensure the block context is created.
 731         context_block::instance($blockinstance->id);
 732
 733         // If the new instance was created, allow it to do additional setup
 734         if ($block = block_instance($blockname, $blockinstance)) {
 735             $block->instance_create();
 736         }
 737     }
 738
 739     public function add_block_at_end_of_default_region($blockname) {
 740         $defaulregion = $this->get_default_region();
 741
 742         $lastcurrentblock = end($this->birecordsbyregion[$defaulregion]);
 743         if ($lastcurrentblock) {
 744             $weight = $lastcurrentblock->weight + 1;
 745         } else {
 746             $weight = 0;
 747         }
 748
 749         if ($this->page->subpage) {
 750             $subpage = $this->page->subpage;
 751         } else {
 752             $subpage = null;
 753         }
 754
 755         // Special case. Course view page type include the course format, but we
 756         // want to add the block non-format-specifically.
 757         $pagetypepattern = $this->page->pagetype;
 758         if (strpos($pagetypepattern, 'course-view') === 0) {
 759             $pagetypepattern = 'course-view-*';
 760         }
 761
 762         // We should end using this for ALL the blocks, making always the 1st option
 763         // the default one to be used. Until then, this is one hack to avoid the
 764         // 'pagetypewarning' message on blocks initial edition (MDL-27829) caused by
 765         // non-existing $pagetypepattern set. This way at least we guarantee one "valid"
 766         // (the FIRST $pagetypepattern will be set)
 767
 768         // We are applying it to all blocks created in mod pages for now and only if the
 769         // default pagetype is not one of the available options
 770         if (preg_match('/^mod-.*-/', $pagetypepattern)) {
 771             $pagetypelist = generate_page_type_patterns($this->page->pagetype, null, $this->page->context);
 772             // Only go for the first if the pagetype is not a valid option
 773             if (is_array($pagetypelist) && !array_key_exists($pagetypepattern, $pagetypelist)) {
 774                 $pagetypepattern = key($pagetypelist);
 775             }
 776         }
 777         // Surely other pages like course-report will need this too, they just are not important
 778         // enough now. This will be decided in the coming days. (MDL-27829, MDL-28150)
 779
 780         $this->add_block($blockname, $defaulregion, $weight, false, $pagetypepattern, $subpage);
 781     }
 782
 783     /**
 784      * Convenience method, calls add_block repeatedly for all the blocks in $blocks.
 785      *
 786      * @param array $blocks array with array keys the region names, and values an array of block names.
 787      * @param string $pagetypepattern optional. Passed to @see add_block()
 788      * @param string $subpagepattern optional. Passed to @see add_block()
 789      */
 790     public function add_blocks($blocks, $pagetypepattern = NULL, $subpagepattern = NULL, $showinsubcontexts=false, $weight=0) {
 791         $this->add_regions(array_keys($blocks), false);
 792         foreach ($blocks as $region => $regionblocks) {
 793             $weight = 0;
 794             foreach ($regionblocks as $blockname) {
 795                 $this->add_block($blockname, $region, $weight, $showinsubcontexts, $pagetypepattern, $subpagepattern);
 796                 $weight += 1;
 797             }
 798         }
 799     }
 800
 801     /**
 802      * Move a block to a new position on this page.
 803      *
 804      * If this block cannot appear on any other pages, then we change defaultposition/weight
 805      * in the block_instances table. Otherwise we just set the position on this page.
 806      *
 807      * @param $blockinstanceid the block instance id.
 808      * @param $newregion the new region name.
 809      * @param $newweight the new weight.
 810      */
 811     public function reposition_block($blockinstanceid, $newregion, $newweight) {
 812         global $DB;
 813
 814         $this->check_region_is_known($newregion);
 815         $inst = $this->find_instance($blockinstanceid);
 816
 817         $bi = $inst->instance;
 818         if ($bi->weight == $bi->defaultweight && $bi->region == $bi->defaultregion &&
 819                 !$bi->showinsubcontexts && strpos($bi->pagetypepattern, '*') === false &&
 820                 (!$this->page->subpage || $bi->subpagepattern)) {
 821
 822             // Set default position
 823             $newbi = new stdClass;
 824             $newbi->id = $bi->id;
 825             $newbi->defaultregion = $newregion;
 826             $newbi->defaultweight = $newweight;
 827             $DB->update_record('block_instances', $newbi);
 828
 829             if ($bi->blockpositionid) {
 830                 $bp = new stdClass;
 831                 $bp->id = $bi->blockpositionid;
 832                 $bp->region = $newregion;
 833                 $bp->weight = $newweight;
 834                 $DB->update_record('block_positions', $bp);
 835             }
 836
 837         } else {
 838             // Just set position on this page.
 839             $bp = new stdClass;
 840             $bp->region = $newregion;
 841             $bp->weight = $newweight;
 842
 843             if ($bi->blockpositionid) {
 844                 $bp->id = $bi->blockpositionid;
 845                 $DB->update_record('block_positions', $bp);
 846
 847             } else {
 848                 $bp->blockinstanceid = $bi->id;
 849                 $bp->contextid = $this->page->context->id;
 850                 $bp->pagetype = $this->page->pagetype;
 851                 if ($this->page->subpage) {
 852                     $bp->subpage = $this->page->subpage;
 853                 } else {
 854                     $bp->subpage = '';
 855                 }
 856                 $bp->visible = $bi->visible;
 857                 $DB->insert_record('block_positions', $bp);
 858             }
 859         }
 860     }
 861
 862     /**
 863      * Find a given block by its instance id
 864      *
 865      * @param integer $instanceid
 866      * @return block_base
 867      */
 868     public function find_instance($instanceid) {
 869         foreach ($this->regions as $region => $notused) {
 870             $this->ensure_instances_exist($region);
 871             foreach($this->blockinstances[$region] as $instance) {
 872                 if ($instance->instance->id == $instanceid) {
 873                     return $instance;
 874                 }
 875             }
 876         }
 877         throw new block_not_on_page_exception($instanceid, $this->page);
 878     }
 879
 880 /// Inner workings =============================================================
 881
 882     /**
 883      * Check whether the page blocks have been loaded yet
 884      *
 885      * @return void Throws coding exception if already loaded
 886      */
 887     protected function check_not_yet_loaded() {
 888         if (!is_null($this->birecordsbyregion)) {
 889             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.');
 890         }
 891     }
 892
 893     /**
 894      * Check whether the page blocks have been loaded yet
 895      *
 896      * Nearly identical to the above function {@link check_not_yet_loaded()} except different message
 897      *
 898      * @return void Throws coding exception if already loaded
 899      */
 900     protected function check_is_loaded() {
 901         if (is_null($this->birecordsbyregion)) {
 902             throw new coding_exception('block_manager has not yet loaded the blocks, to it is too soon to request the information you asked for.');
 903         }
 904     }
 905
 906     /**
 907      * Check if a block type is known and usable
 908      *
 909      * @param string $blockname The block type name to search for
 910      * @param bool $includeinvisible Include disabled block types in the initial pass
 911      * @return void Coding Exception thrown if unknown or not enabled
 912      */
 913     protected function check_known_block_type($blockname, $includeinvisible = false) {
 914         if (!$this->is_known_block_type($blockname, $includeinvisible)) {
 915             if ($this->is_known_block_type($blockname, true)) {
 916                 throw new coding_exception('Unknown block type ' . $blockname);
 917             } else {
 918                 throw new coding_exception('Block type ' . $blockname . ' has been disabled by the administrator.');
 919             }
 920         }
 921     }
 922
 923     /**
 924      * Check if a region is known by its name
 925      *
 926      * @param string $region
 927      * @return void Coding Exception thrown if the region is not known
 928      */
 929     protected function check_region_is_known($region) {
 930         if (!$this->is_known_region($region)) {
 931             throw new coding_exception('Trying to reference an unknown block region ' . $region);
 932         }
 933     }
 934
 935     /**
 936      * Returns an array of region names as keys and nested arrays for values
 937      *
 938      * @return array an array where the array keys are the region names, and the array
 939      * values are empty arrays.
 940      */
 941     protected function prepare_per_region_arrays() {
 942         $result = array();
 943         foreach ($this->regions as $region => $notused) {
 944             $result[$region] = array();
 945         }
 946         return $result;
 947     }
 948
 949     /**
 950      * Create a set of new block instance from a record array
 951      *
 952      * @param array $birecords An array of block instance records
 953      * @return array An array of instantiated block_instance objects
 954      */
 955     protected function create_block_instances($birecords) {
 956         $results = array();
 957         foreach ($birecords as $record) {
 958             if ($blockobject = block_instance($record->blockname, $record, $this->page)) {
 959                 $results[] = $blockobject;
 960             }
 961         }
 962         return $results;
 963     }
 964
 965     /**
 966      * Create all the block instances for all the blocks that were loaded by
 967      * load_blocks. This is used, for example, to ensure that all blocks get a
 968      * chance to initialise themselves via the {@link block_base::specialize()}
 969      * method, before any output is done.
 970      */
 971     public function create_all_block_instances() {
 972         foreach ($this->get_regions() as $region) {
 973             $this->ensure_instances_exist($region);
 974         }
 975     }
 976
 977     /**
 978      * Return an array of content objects from a set of block instances
 979      *
 980      * @param array $instances An array of block instances
 981      * @param renderer_base The renderer to use.
 982      * @param string $region the region name.
 983      * @return array An array of block_content (and possibly block_move_target) objects.
 984      */
 985     protected function create_block_contents($instances, $output, $region) {
 986         $results = array();
 987
 988         $lastweight = 0;
 989         $lastblock = 0;
 990         if ($this->movingblock) {
 991             $first = reset($instances);
 992             if ($first) {
 993                 $lastweight = $first->instance->weight - 2;
 994             }
 995         }
 996
 997         foreach ($instances as $instance) {
 998             $content = $instance->get_content_for_output($output);
 999             if (empty($content)) {
1000                 continue;
1001             }
1002
1003             if ($this->movingblock && $lastweight != $instance->instance->weight &&
1004                     $content->blockinstanceid != $this->movingblock && $lastblock != $this->movingblock) {
1005                 $results[] = new block_move_target($this->get_move_target_url($region, ($lastweight + $instance->instance->weight)/2));
1006             }
1007
1008             if ($content->blockinstanceid == $this->movingblock) {
1009                 $content->add_class('beingmoved');
1010                 $content->annotation .= get_string('movingthisblockcancel', 'block',
1011                         html_writer::link($this->page->url, get_string('cancel')));
1012             }
1013
1014             $results[] = $content;
1015             $lastweight = $instance->instance->weight;
1016             $lastblock = $instance->instance->id;
1017         }
1018
1019         if ($this->movingblock && $lastblock != $this->movingblock) {
1020             $results[] = new block_move_target($this->get_move_target_url($region, $lastweight + 1));
1021         }
1022         return $results;
1023     }
1024
1025     /**
1026      * Ensure block instances exist for a given region
1027      *
1028      * @param string $region Check for bi's with the instance with this name
1029      */
1030     protected function ensure_instances_exist($region) {
1031         $this->check_region_is_known($region);
1032         if (!array_key_exists($region, $this->blockinstances)) {
1033             $this->blockinstances[$region] =
1034                     $this->create_block_instances($this->birecordsbyregion[$region]);
1035         }
1036     }
1037
1038     /**
1039      * Ensure that there is some content within the given region
1040      *
1041      * @param string $region The name of the region to check
1042      */
1043     public function ensure_content_created($region, $output) {
1044         $this->ensure_instances_exist($region);
1045         if (!array_key_exists($region, $this->visibleblockcontent)) {
1046             $contents = array();
1047             if (array_key_exists($region, $this->extracontent)) {
1048                 $contents = $this->extracontent[$region];
1049             }
1050             $contents = array_merge($contents, $this->create_block_contents($this->blockinstances[$region], $output, $region));
1051             if ($region == $this->defaultregion) {
1052                 $addblockui = block_add_block_ui($this->page, $output);
1053                 if ($addblockui) {
1054                     $contents[] = $addblockui;
1055                 }
1056             }
1057             $this->visibleblockcontent[$region] = $contents;
1058         }
1059     }
1060
1061 /// Process actions from the URL ===============================================
1062
1063     /**
1064      * Get the appropriate list of editing icons for a block. This is used
1065      * to set {@link block_contents::$controls} in {@link block_base::get_contents_for_output()}.
1066      *
1067      * @param $output The core_renderer to use when generating the output. (Need to get icon paths.)
1068      * @return an array in the format for {@link block_contents::$controls}
1069      */
1070     public function edit_controls($block) {
1071         global $CFG;
1072
1073         $controls = array();
1074         $actionurl = $this->page->url->out(false, array('sesskey'=> sesskey()));
1075         $blocktitle = $block->title;
1076         if (empty($blocktitle)) {
1077             $blocktitle = $block->arialabel;
1078         }
1079
1080         if ($this->page->user_can_edit_blocks()) {
1081             // Move icon.
1082             $str = new lang_string('moveblock', 'block', $blocktitle);
1083             $controls[] = new action_menu_link_primary(
1084                 new moodle_url($actionurl, array('bui_moveid' => $block->instance->id)),
1085                 new pix_icon('t/move', $str, 'moodle', array('class' => 'iconsmall', 'title' => '')),
1086                 $str,
1087                 array('class' => 'editing_move')
1088             );
1089
1090         }
1091
1092         if ($this->page->user_can_edit_blocks() || $block->user_can_edit()) {
1093             // Edit config icon - always show - needed for positioning UI.
1094             $str = new lang_string('configureblock', 'block', $blocktitle);
1095             $controls[] = new action_menu_link_secondary(
1096                 new moodle_url($actionurl, array('bui_editid' => $block->instance->id)),
1097                 new pix_icon('t/edit', $str, 'moodle', array('class' => 'iconsmall', 'title' => '')),
1098                 $str,
1099                 array('class' => 'editing_edit')
1100             );
1101
1102         }
1103
1104         if ($this->page->user_can_edit_blocks() && $block->instance_can_be_hidden()) {
1105             // Show/hide icon.
1106             if ($block->instance->visible) {
1107                 $str = new lang_string('hideblock', 'block', $blocktitle);
1108                 $url = new moodle_url($actionurl, array('bui_hideid' => $block->instance->id));
1109                 $icon = new pix_icon('t/hide', $str, 'moodle', array('class' => 'iconsmall', 'title' => ''));
1110                 $attributes = array('class' => 'editing_hide');
1111             } else {
1112                 $str = new lang_string('showblock', 'block', $blocktitle);
1113                 $url = new moodle_url($actionurl, array('bui_showid' => $block->instance->id));
1114                 $icon = new pix_icon('t/show', $str, 'moodle', array('class' => 'iconsmall', 'title' => ''));
1115                 $attributes = array('class' => 'editing_show');
1116             }
1117             $controls[] = new action_menu_link_secondary($url, $icon, $str, $attributes);
1118         }
1119
1120         // Assign roles icon.
1121         if ($this->page->pagetype != 'my-index' && has_capability('moodle/role:assign', $block->context)) {
1122             //TODO: please note it is sloppy to pass urls through page parameters!!
1123             //      it is shortened because some web servers (e.g. IIS by default) give
1124             //      a 'security' error if you try to pass a full URL as a GET parameter in another URL.
1125             $return = $this->page->url->out(false);
1126             $return = str_replace($CFG->wwwroot . '/', '', $return);
1127
1128             $rolesurl = new moodle_url('/admin/roles/assign.php', array('contextid'=>$block->context->id,
1129                                                                          'returnurl'=>$return));
1130             // Delete icon.
1131             $str = new lang_string('assignrolesinblock', 'block', $blocktitle);
1132             $controls[] = new action_menu_link_secondary(
1133                 $rolesurl,
1134                 new pix_icon('t/assignroles', $str, 'moodle', array('class' => 'iconsmall', 'title' => '')),
1135                 $str,
1136                 array('class' => 'editing_roles')
1137             );
1138         }
1139
1140         if ($this->user_can_delete_block($block)) {
1141             // Delete icon.
1142             $str = new lang_string('deleteblock', 'block', $blocktitle);
1143             $controls[] = new action_menu_link_secondary(
1144                 new moodle_url($actionurl, array('bui_deleteid' => $block->instance->id)),
1145                 new pix_icon('t/delete', $str, 'moodle', array('class' => 'iconsmall', 'title' => '')),
1146                 $str,
1147                 array('class' => 'editing_delete')
1148             );
1149         }
1150
1151         return $controls;
1152     }
1153
1154     /**
1155      * @param block_base $block a block that appears on this page.
1156      * @return boolean boolean whether the currently logged in user is allowed to delete this block.
1157      */
1158     protected function user_can_delete_block($block) {
1159         return $this->page->user_can_edit_blocks() && $block->user_can_edit() &&
1160                 $block->user_can_addto($this->page) &&
1161                 !in_array($block->instance->blockname, self::get_undeletable_block_types());
1162     }
1163
1164     /**
1165      * Process any block actions that were specified in the URL.
1166      *
1167      * @return boolean true if anything was done. False if not.
1168      */
1169     public function process_url_actions() {
1170         if (!$this->page->user_is_editing()) {
1171             return false;
1172         }
1173         return $this->process_url_add() || $this->process_url_delete() ||
1174             $this->process_url_show_hide() || $this->process_url_edit() ||
1175             $this->process_url_move();
1176     }
1177
1178     /**
1179      * Handle adding a block.
1180      * @return boolean true if anything was done. False if not.
1181      */
1182     public function process_url_add() {
1183         $blocktype = optional_param('bui_addblock', null, PARAM_PLUGIN);
1184         if (!$blocktype) {
1185             return false;
1186         }
1187
1188         require_sesskey();
1189
1190         if (!$this->page->user_can_edit_blocks()) {
1191             throw new moodle_exception('nopermissions', '', $this->page->url->out(), get_string('addblock'));
1192         }
1193
1194         if (!array_key_exists($blocktype, $this->get_addable_blocks())) {
1195             throw new moodle_exception('cannotaddthisblocktype', '', $this->page->url->out(), $blocktype);
1196         }
1197
1198         $this->add_block_at_end_of_default_region($blocktype);
1199
1200         // If the page URL was a guess, it will contain the bui_... param, so we must make sure it is not there.
1201         $this->page->ensure_param_not_in_url('bui_addblock');
1202
1203         return true;
1204     }
1205
1206     /**
1207      * Handle deleting a block.
1208      * @return boolean true if anything was done. False if not.
1209      */
1210     public function process_url_delete() {
1211         global $CFG, $PAGE, $OUTPUT;
1212
1213         $blockid = optional_param('bui_deleteid', null, PARAM_INT);
1214         $confirmdelete = optional_param('bui_confirm', null, PARAM_INT);
1215
1216         if (!$blockid) {
1217             return false;
1218         }
1219
1220         require_sesskey();
1221         $block = $this->page->blocks->find_instance($blockid);
1222         if (!$this->user_can_delete_block($block)) {
1223             throw new moodle_exception('nopermissions', '', $this->page->url->out(), get_string('deleteablock'));
1224         }
1225
1226         if (!$confirmdelete) {
1227             $deletepage = new moodle_page();
1228             $deletepage->set_pagelayout('admin');
1229             $deletepage->set_course($this->page->course);
1230             $deletepage->set_context($this->page->context);
1231             if ($this->page->cm) {
1232                 $deletepage->set_cm($this->page->cm);
1233             }
1234
1235             $deleteurlbase = str_replace($CFG->wwwroot . '/', '/', $this->page->url->out_omit_querystring());
1236             $deleteurlparams = $this->page->url->params();
1237             $deletepage->set_url($deleteurlbase, $deleteurlparams);
1238             $deletepage->set_block_actions_done();
1239             // At this point we are either going to redirect, or display the form, so
1240             // overwrite global $PAGE ready for this. (Formslib refers to it.)
1241             $PAGE = $deletepage;
1242             //some functions like MoodleQuickForm::addHelpButton use $OUTPUT so we need to replace that too
1243             $output = $deletepage->get_renderer('core');
1244             $OUTPUT = $output;
1245
1246             $site = get_site();
1247             $blocktitle = $block->get_title();
1248             $strdeletecheck = get_string('deletecheck', 'block', $blocktitle);
1249             $message = get_string('deleteblockcheck', 'block', $blocktitle);
1250
1251             // If the block is being shown in sub contexts display a warning.
1252             if ($block->instance->showinsubcontexts == 1) {
1253                 $parentcontext = context::instance_by_id($block->instance->parentcontextid);
1254                 $systemcontext = context_system::instance();
1255                 $messagestring = new stdClass();
1256                 $messagestring->location = $parentcontext->get_context_name();
1257
1258                 // Checking for blocks that may have visibility on the front page and pages added on that.
1259                 if ($parentcontext->id != $systemcontext->id && is_inside_frontpage($parentcontext)) {
1260                     $messagestring->pagetype = get_string('showonfrontpageandsubs', 'block');
1261                 } else {
1262                     $pagetypes = generate_page_type_patterns($this->page->pagetype, $parentcontext);
1263                     $messagestring->pagetype = $block->instance->pagetypepattern;
1264                     if (isset($pagetypes[$block->instance->pagetypepattern])) {
1265                         $messagestring->pagetype = $pagetypes[$block->instance->pagetypepattern];
1266                     }
1267                 }
1268
1269                 $message = get_string('deleteblockwarning', 'block', $messagestring);
1270             }
1271
1272             $PAGE->navbar->add($strdeletecheck);
1273             $PAGE->set_title($blocktitle . ': ' . $strdeletecheck);
1274             $PAGE->set_heading($site->fullname);
1275             echo $OUTPUT->header();
1276             $confirmurl = new moodle_url($deletepage->url, array('sesskey' => sesskey(), 'bui_deleteid' => $block->instance->id, 'bui_confirm' => 1));
1277             $cancelurl = new moodle_url($deletepage->url);
1278             $yesbutton = new single_button($confirmurl, get_string('yes'));
1279             $nobutton = new single_button($cancelurl, get_string('no'));
1280             echo $OUTPUT->confirm($message, $yesbutton, $nobutton);
1281             echo $OUTPUT->footer();
1282             // Make sure that nothing else happens after we have displayed this form.
1283             exit;
1284         } else {
1285             blocks_delete_instance($block->instance);
1286             // bui_deleteid and bui_confirm should not be in the PAGE url.
1287             $this->page->ensure_param_not_in_url('bui_deleteid');
1288             $this->page->ensure_param_not_in_url('bui_confirm');
1289             return true;
1290         }
1291     }
1292
1293     /**
1294      * Handle showing or hiding a block.
1295      * @return boolean true if anything was done. False if not.
1296      */
1297     public function process_url_show_hide() {
1298         if ($blockid = optional_param('bui_hideid', null, PARAM_INT)) {
1299             $newvisibility = 0;
1300         } else if ($blockid = optional_param('bui_showid', null, PARAM_INT)) {
1301             $newvisibility = 1;
1302         } else {
1303             return false;
1304         }
1305
1306         require_sesskey();
1307
1308         $block = $this->page->blocks->find_instance($blockid);
1309
1310         if (!$this->page->user_can_edit_blocks()) {
1311             throw new moodle_exception('nopermissions', '', $this->page->url->out(), get_string('hideshowblocks'));
1312         } else if (!$block->instance_can_be_hidden()) {
1313             return false;
1314         }
1315
1316         blocks_set_visibility($block->instance, $this->page, $newvisibility);
1317
1318         // If the page URL was a guses, it will contain the bui_... param, so we must make sure it is not there.
1319         $this->page->ensure_param_not_in_url('bui_hideid');
1320         $this->page->ensure_param_not_in_url('bui_showid');
1321
1322         return true;
1323     }
1324
1325     /**
1326      * Handle showing/processing the submission from the block editing form.
1327      * @return boolean true if the form was submitted and the new config saved. Does not
1328      *      return if the editing form was displayed. False otherwise.
1329      */
1330     public function process_url_edit() {
1331         global $CFG, $DB, $PAGE, $OUTPUT;
1332
1333         $blockid = optional_param('bui_editid', null, PARAM_INT);
1334         if (!$blockid) {
1335             return false;
1336         }
1337
1338         require_sesskey();
1339         require_once($CFG->dirroot . '/blocks/edit_form.php');
1340
1341         $block = $this->find_instance($blockid);
1342
1343         if (!$block->user_can_edit() && !$this->page->user_can_edit_blocks()) {
1344             throw new moodle_exception('nopermissions', '', $this->page->url->out(), get_string('editblock'));
1345         }
1346
1347         $editpage = new moodle_page();
1348         $editpage->set_pagelayout('admin');
1349         $editpage->set_course($this->page->course);
1350         //$editpage->set_context($block->context);
1351         $editpage->set_context($this->page->context);
1352         if ($this->page->cm) {
1353             $editpage->set_cm($this->page->cm);
1354         }
1355         $editurlbase = str_replace($CFG->wwwroot . '/', '/', $this->page->url->out_omit_querystring());
1356         $editurlparams = $this->page->url->params();
1357         $editurlparams['bui_editid'] = $blockid;
1358         $editpage->set_url($editurlbase, $editurlparams);
1359         $editpage->set_block_actions_done();
1360         // At this point we are either going to redirect, or display the form, so
1361         // overwrite global $PAGE ready for this. (Formslib refers to it.)
1362         $PAGE = $editpage;
1363         //some functions like MoodleQuickForm::addHelpButton use $OUTPUT so we need to replace that to
1364         $output = $editpage->get_renderer('core');
1365         $OUTPUT = $output;
1366
1367         $formfile = $CFG->dirroot . '/blocks/' . $block->name() . '/edit_form.php';
1368         if (is_readable($formfile)) {
1369             require_once($formfile);
1370             $classname = 'block_' . $block->name() . '_edit_form';
1371             if (!class_exists($classname)) {
1372                 $classname = 'block_edit_form';
1373             }
1374         } else {
1375             $classname = 'block_edit_form';
1376         }
1377
1378         $mform = new $classname($editpage->url, $block, $this->page);
1379         $mform->set_data($block->instance);
1380
1381         if ($mform->is_cancelled()) {
1382             redirect($this->page->url);
1383
1384         } else if ($data = $mform->get_data()) {
1385             $bi = new stdClass;
1386             $bi->id = $block->instance->id;
1387
1388             // This may get overwritten by the special case handling below.
1389             $bi->pagetypepattern = $data->bui_pagetypepattern;
1390             $bi->showinsubcontexts = (bool) $data->bui_contexts;
1391             if (empty($data->bui_subpagepattern) || $data->bui_subpagepattern == '%@NULL@%') {
1392                 $bi->subpagepattern = null;
1393             } else {
1394                 $bi->subpagepattern = $data->bui_subpagepattern;
1395             }
1396
1397             $systemcontext = context_system::instance();
1398             $frontpagecontext = context_course::instance(SITEID);
1399             $parentcontext = context::instance_by_id($data->bui_parentcontextid);
1400
1401             // Updating stickiness and contexts.  See MDL-21375 for details.
1402             if (has_capability('moodle/site:manageblocks', $parentcontext)) { // Check permissions in destination
1403
1404                 // Explicitly set the default context
1405                 $bi->parentcontextid = $parentcontext->id;
1406
1407                 if ($data->bui_editingatfrontpage) {   // The block is being edited on the front page
1408
1409                     // The interface here is a special case because the pagetype pattern is
1410                     // totally derived from the context menu.  Here are the excpetions.   MDL-30340
1411
1412                     switch ($data->bui_contexts) {
1413                         case BUI_CONTEXTS_ENTIRE_SITE:
1414                             // The user wants to show the block across the entire site
1415                             $bi->parentcontextid = $systemcontext->id;
1416                             $bi->showinsubcontexts = true;
1417                             $bi->pagetypepattern  = '*';
1418                             break;
1419                         case BUI_CONTEXTS_FRONTPAGE_SUBS:
1420                             // The user wants the block shown on the front page and all subcontexts
1421                             $bi->parentcontextid = $frontpagecontext->id;
1422                             $bi->showinsubcontexts = true;
1423                             $bi->pagetypepattern  = '*';
1424                             break;
1425                         case BUI_CONTEXTS_FRONTPAGE_ONLY:
1426                             // The user want to show the front page on the frontpage only
1427                             $bi->parentcontextid = $frontpagecontext->id;
1428                             $bi->showinsubcontexts = false;
1429                             $bi->pagetypepattern  = 'site-index';
1430                             // This is the only relevant page type anyway but we'll set it explicitly just
1431                             // in case the front page grows site-index-* subpages of its own later
1432                             break;
1433                     }
1434                 }
1435             }
1436
1437             $bits = explode('-', $bi->pagetypepattern);
1438             // hacks for some contexts
1439             if (($parentcontext->contextlevel == CONTEXT_COURSE) && ($parentcontext->instanceid != SITEID)) {
1440                 // For course context
1441                 // is page type pattern is mod-*, change showinsubcontext to 1
1442                 if ($bits[0] == 'mod' || $bi->pagetypepattern == '*') {
1443                     $bi->showinsubcontexts = 1;
1444                 } else {
1445                     $bi->showinsubcontexts = 0;
1446                 }
1447             } else  if ($parentcontext->contextlevel == CONTEXT_USER) {
1448                 // for user context
1449                 // subpagepattern should be null
1450                 if ($bits[0] == 'user' or $bits[0] == 'my') {
1451                     // we don't need subpagepattern in usercontext
1452                     $bi->subpagepattern = null;
1453                 }
1454             }
1455
1456             $bi->defaultregion = $data->bui_defaultregion;
1457             $bi->defaultweight = $data->bui_defaultweight;
1458             $DB->update_record('block_instances', $bi);
1459
1460             if (!empty($block->config)) {
1461                 $config = clone($block->config);
1462             } else {
1463                 $config = new stdClass;
1464             }
1465             foreach ($data as $configfield => $value) {
1466                 if (strpos($configfield, 'config_') !== 0) {
1467                     continue;
1468                 }
1469                 $field = substr($configfield, 7);
1470                 $config->$field = $value;
1471             }
1472             $block->instance_config_save($config);
1473
1474             $bp = new stdClass;
1475             $bp->visible = $data->bui_visible;
1476             $bp->region = $data->bui_region;
1477             $bp->weight = $data->bui_weight;
1478             $needbprecord = !$data->bui_visible || $data->bui_region != $data->bui_defaultregion ||
1479                     $data->bui_weight != $data->bui_defaultweight;
1480
1481             if ($block->instance->blockpositionid && !$needbprecord) {
1482                 $DB->delete_records('block_positions', array('id' => $block->instance->blockpositionid));
1483
1484             } else if ($block->instance->blockpositionid && $needbprecord) {
1485                 $bp->id = $block->instance->blockpositionid;
1486                 $DB->update_record('block_positions', $bp);
1487
1488             } else if ($needbprecord) {
1489                 $bp->blockinstanceid = $block->instance->id;
1490                 $bp->contextid = $this->page->context->id;
1491                 $bp->pagetype = $this->page->pagetype;
1492                 if ($this->page->subpage) {
1493                     $bp->subpage = $this->page->subpage;
1494                 } else {
1495                     $bp->subpage = '';
1496                 }
1497                 $DB->insert_record('block_positions', $bp);
1498             }
1499
1500             redirect($this->page->url);
1501
1502         } else {
1503             $strheading = get_string('blockconfiga', 'moodle', $block->get_title());
1504             $editpage->set_title($strheading);
1505             $editpage->set_heading($strheading);
1506             $bits = explode('-', $this->page->pagetype);
1507             if ($bits[0] == 'tag' && !empty($this->page->subpage)) {
1508                 // better navbar for tag pages
1509                 $editpage->navbar->add(get_string('tags'), new moodle_url('/tag/'));
1510                 $tag = tag_get('id', $this->page->subpage, '*');
1511                 // tag search page doesn't have subpageid
1512                 if ($tag) {
1513                     $editpage->navbar->add($tag->name, new moodle_url('/tag/index.php', array('id'=>$tag->id)));
1514                 }
1515             }
1516             $editpage->navbar->add($block->get_title());
1517             $editpage->navbar->add(get_string('configuration'));
1518             echo $output->header();
1519             echo $output->heading($strheading, 2);
1520             $mform->display();
1521             echo $output->footer();
1522             exit;
1523         }
1524     }
1525
1526     /**
1527      * Handle showing/processing the submission from the block editing form.
1528      * @return boolean true if the form was submitted and the new config saved. Does not
1529      *      return if the editing form was displayed. False otherwise.
1530      */
1531     public function process_url_move() {
1532         global $CFG, $DB, $PAGE;
1533
1534         $blockid = optional_param('bui_moveid', null, PARAM_INT);
1535         if (!$blockid) {
1536             return false;
1537         }
1538
1539         require_sesskey();
1540
1541         $block = $this->find_instance($blockid);
1542
1543         if (!$this->page->user_can_edit_blocks()) {
1544             throw new moodle_exception('nopermissions', '', $this->page->url->out(), get_string('editblock'));
1545         }
1546
1547         $newregion = optional_param('bui_newregion', '', PARAM_ALPHANUMEXT);
1548         $newweight = optional_param('bui_newweight', null, PARAM_FLOAT);
1549         if (!$newregion || is_null($newweight)) {
1550             // Don't have a valid target position yet, must be just starting the move.
1551             $this->movingblock = $blockid;
1552             $this->page->ensure_param_not_in_url('bui_moveid');
1553             return false;
1554         }
1555
1556         if (!$this->is_known_region($newregion)) {
1557             throw new moodle_exception('unknownblockregion', '', $this->page->url, $newregion);
1558         }
1559
1560         // Move this block. This may involve moving other nearby blocks.
1561         $blocks = $this->birecordsbyregion[$newregion];
1562
1563         $maxweight = self::MAX_WEIGHT;
1564         $minweight = -self::MAX_WEIGHT;
1565
1566         // Initialise the used weights and spareweights array with the default values
1567         $spareweights = array();
1568         $usedweights = array();
1569         for ($i = $minweight; $i <= $maxweight; $i++) {
1570             $spareweights[$i] = $i;
1571             $usedweights[$i] = array();
1572         }
1573
1574         // Check each block and sort out where we have used weights
1575         foreach ($blocks as $bi) {
1576             if ($bi->weight > $maxweight) {
1577                 // If this statement is true then the blocks weight is more than the
1578                 // current maximum. To ensure that we can get the best block position
1579                 // we will initialise elements within the usedweights and spareweights
1580                 // arrays between the blocks weight (which will then be the new max) and
1581                 // the current max
1582                 $parseweight = $bi->weight;
1583                 while (!array_key_exists($parseweight, $usedweights)) {
1584                     $usedweights[$parseweight] = array();
1585                     $spareweights[$parseweight] = $parseweight;
1586                     $parseweight--;
1587                 }
1588                 $maxweight = $bi->weight;
1589             } else if ($bi->weight < $minweight) {
1590                 // As above except this time the blocks weight is LESS than the
1591                 // the current minimum, so we will initialise the array from the
1592                 // blocks weight (new minimum) to the current minimum
1593                 $parseweight = $bi->weight;
1594                 while (!array_key_exists($parseweight, $usedweights)) {
1595                     $usedweights[$parseweight] = array();
1596                     $spareweights[$parseweight] = $parseweight;
1597                     $parseweight++;
1598                 }
1599                 $minweight = $bi->weight;
1600             }
1601             if ($bi->id != $block->instance->id) {
1602                 unset($spareweights[$bi->weight]);
1603                 $usedweights[$bi->weight][] = $bi->id;
1604             }
1605         }
1606
1607         // First we find the nearest gap in the list of weights.
1608         $bestdistance = max(abs($newweight - self::MAX_WEIGHT), abs($newweight + self::MAX_WEIGHT)) + 1;
1609         $bestgap = null;
1610         foreach ($spareweights as $spareweight) {
1611             if (abs($newweight - $spareweight) < $bestdistance) {
1612                 $bestdistance = abs($newweight - $spareweight);
1613                 $bestgap = $spareweight;
1614             }
1615         }
1616
1617         // If there is no gap, we have to go outside -self::MAX_WEIGHT .. self::MAX_WEIGHT.
1618         if (is_null($bestgap)) {
1619             $bestgap = self::MAX_WEIGHT + 1;
1620             while (!empty($usedweights[$bestgap])) {
1621                 $bestgap++;
1622             }
1623         }
1624
1625         // Now we know the gap we are aiming for, so move all the blocks along.
1626         if ($bestgap < $newweight) {
1627             $newweight = floor($newweight);
1628             for ($weight = $bestgap + 1; $weight <= $newweight; $weight++) {
1629                 foreach ($usedweights[$weight] as $biid) {
1630                     $this->reposition_block($biid, $newregion, $weight - 1);
1631                 }
1632             }
1633             $this->reposition_block($block->instance->id, $newregion, $newweight);
1634         } else {
1635             $newweight = ceil($newweight);
1636             for ($weight = $bestgap - 1; $weight >= $newweight; $weight--) {
1637                 if (array_key_exists($weight, $usedweights)) {
1638                     foreach ($usedweights[$weight] as $biid) {
1639                         $this->reposition_block($biid, $newregion, $weight + 1);
1640                     }
1641                 }
1642             }
1643             $this->reposition_block($block->instance->id, $newregion, $newweight);
1644         }
1645
1646         $this->page->ensure_param_not_in_url('bui_moveid');
1647         $this->page->ensure_param_not_in_url('bui_newregion');
1648         $this->page->ensure_param_not_in_url('bui_newweight');
1649         return true;
1650     }
1651
1652     /**
1653      * Turns the display of normal blocks either on or off.
1654      *
1655      * @param bool $setting
1656      */
1657     public function show_only_fake_blocks($setting = true) {
1658         $this->fakeblocksonly = $setting;
1659     }
1660 }
1661
1662 /// Helper functions for working with block classes ============================
1663
1664 /**
1665  * Call a class method (one that does not require a block instance) on a block class.
1666  *
1667  * @param string $blockname the name of the block.
1668  * @param string $method the method name.
1669  * @param array $param parameters to pass to the method.
1670  * @return mixed whatever the method returns.
1671  */
1672 function block_method_result($blockname, $method, $param = NULL) {
1673     if(!block_load_class($blockname)) {
1674         return NULL;
1675     }
1676     return call_user_func(array('block_'.$blockname, $method), $param);
1677 }
1678
1679 /**
1680  * Creates a new instance of the specified block class.
1681  *
1682  * @param string $blockname the name of the block.
1683  * @param $instance block_instances DB table row (optional).
1684  * @param moodle_page $page the page this block is appearing on.
1685  * @return block_base the requested block instance.
1686  */
1687 function block_instance($blockname, $instance = NULL, $page = NULL) {
1688     if(!block_load_class($blockname)) {
1689         return false;
1690     }
1691     $classname = 'block_'.$blockname;
1692     $retval = new $classname;
1693     if($instance !== NULL) {
1694         if (is_null($page)) {
1695             global $PAGE;
1696             $page = $PAGE;
1697         }
1698         $retval->_load_instance($instance, $page);
1699     }
1700     return $retval;
1701 }
1702
1703 /**
1704  * Load the block class for a particular type of block.
1705  *
1706  * @param string $blockname the name of the block.
1707  * @return boolean success or failure.
1708  */
1709 function block_load_class($blockname) {
1710     global $CFG;
1711
1712     if(empty($blockname)) {
1713         return false;
1714     }
1715
1716     $classname = 'block_'.$blockname;
1717
1718     if(class_exists($classname)) {
1719         return true;
1720     }
1721
1722     $blockpath = $CFG->dirroot.'/blocks/'.$blockname.'/block_'.$blockname.'.php';
1723
1724     if (file_exists($blockpath)) {
1725         require_once($CFG->dirroot.'/blocks/moodleblock.class.php');
1726         include_once($blockpath);
1727     }else{
1728         //debugging("$blockname code does not exist in $blockpath", DEBUG_DEVELOPER);
1729         return false;
1730     }
1731
1732     return class_exists($classname);
1733 }
1734
1735 /**
1736  * Given a specific page type, return all the page type patterns that might
1737  * match it.
1738  *
1739  * @param string $pagetype for example 'course-view-weeks' or 'mod-quiz-view'.
1740  * @return array an array of all the page type patterns that might match this page type.
1741  */
1742 function matching_page_type_patterns($pagetype) {
1743     $patterns = array($pagetype);
1744     $bits = explode('-', $pagetype);
1745     if (count($bits) == 3 && $bits[0] == 'mod') {
1746         if ($bits[2] == 'view') {
1747             $patterns[] = 'mod-*-view';
1748         } else if ($bits[2] == 'index') {
1749             $patterns[] = 'mod-*-index';
1750         }
1751     }
1752     while (count($bits) > 0) {
1753         $patterns[] = implode('-', $bits) . '-*';
1754         array_pop($bits);
1755     }
1756     $patterns[] = '*';
1757     return $patterns;
1758 }
1759
1760 /**
1761  * Give an specific pattern, return all the page type patterns that would also match it.
1762  *
1763  * @param  string $pattern the pattern, e.g. 'mod-forum-*' or 'mod-quiz-view'.
1764  * @return array of all the page type patterns matching.
1765  */
1766 function matching_page_type_patterns_from_pattern($pattern) {
1767     $patterns = array($pattern);
1768     if ($pattern === '*') {
1769         return $patterns;
1770     }
1771
1772     // Only keep the part before the star because we will append -* to all the bits.
1773     $star = strpos($pattern, '-*');
1774     if ($star !== false) {
1775         $pattern = substr($pattern, 0, $star);
1776     }
1777
1778     $patterns = array_merge($patterns, matching_page_type_patterns($pattern));
1779     $patterns = array_unique($patterns);
1780
1781     return $patterns;
1782 }
1783
1784 /**
1785  * Given a specific page type, parent context and currect context, return all the page type patterns
1786  * that might be used by this block.
1787  *
1788  * @param string $pagetype for example 'course-view-weeks' or 'mod-quiz-view'.
1789  * @param stdClass $parentcontext Block's parent context
1790  * @param stdClass $currentcontext Current context of block
1791  * @return array an array of all the page type patterns that might match this page type.
1792  */
1793 function generate_page_type_patterns($pagetype, $parentcontext = null, $currentcontext = null) {
1794     global $CFG; // Required for includes bellow.
1795
1796     $bits = explode('-', $pagetype);
1797
1798     $core = core_component::get_core_subsystems();
1799     $plugins = core_component::get_plugin_types();
1800
1801     //progressively strip pieces off the page type looking for a match
1802     $componentarray = null;
1803     for ($i = count($bits); $i > 0; $i--) {
1804         $possiblecomponentarray = array_slice($bits, 0, $i);
1805         $possiblecomponent = implode('', $possiblecomponentarray);
1806
1807         // Check to see if the component is a core component
1808         if (array_key_exists($possiblecomponent, $core) && !empty($core[$possiblecomponent])) {
1809             $libfile = $core[$possiblecomponent].'/lib.php';
1810             if (file_exists($libfile)) {
1811                 require_once($libfile);
1812                 $function = $possiblecomponent.'_page_type_list';
1813                 if (function_exists($function)) {
1814                     if ($patterns = $function($pagetype, $parentcontext, $currentcontext)) {
1815                         break;
1816                     }
1817                 }
1818             }
1819         }
1820
1821         //check the plugin directory and look for a callback
1822         if (array_key_exists($possiblecomponent, $plugins) && !empty($plugins[$possiblecomponent])) {
1823
1824             //We've found a plugin type. Look for a plugin name by getting the next section of page type
1825             if (count($bits) > $i) {
1826                 $pluginname = $bits[$i];
1827                 $directory = core_component::get_plugin_directory($possiblecomponent, $pluginname);
1828                 if (!empty($directory)){
1829                     $libfile = $directory.'/lib.php';
1830                     if (file_exists($libfile)) {
1831                         require_once($libfile);
1832                         $function = $possiblecomponent.'_'.$pluginname.'_page_type_list';
1833                         if (!function_exists($function)) {
1834                             $function = $pluginname.'_page_type_list';
1835                         }
1836                         if (function_exists($function)) {
1837                             if ($patterns = $function($pagetype, $parentcontext, $currentcontext)) {
1838                                 break;
1839                             }
1840                         }
1841                     }
1842                 }
1843             }
1844
1845             //we'll only get to here if we still don't have any patterns
1846             //the plugin type may have a callback
1847             $directory = $plugins[$possiblecomponent];
1848             $libfile = $directory.'/lib.php';
1849             if (file_exists($libfile)) {
1850                 require_once($libfile);
1851                 $function = $possiblecomponent.'_page_type_list';
1852                 if (function_exists($function)) {
1853                     if ($patterns = $function($pagetype, $parentcontext, $currentcontext)) {
1854                         break;
1855                     }
1856                 }
1857             }
1858         }
1859     }
1860
1861     if (empty($patterns)) {
1862         $patterns = default_page_type_list($pagetype, $parentcontext, $currentcontext);
1863     }
1864
1865     // Ensure that the * pattern is always available if editing block 'at distance', so
1866     // we always can 'bring back' it to the original context. MDL-30340
1867     if ((!isset($currentcontext) or !isset($parentcontext) or $currentcontext->id != $parentcontext->id) && !isset($patterns['*'])) {
1868         // TODO: We could change the string here, showing its 'bring back' meaning
1869         $patterns['*'] = get_string('page-x', 'pagetype');
1870     }
1871
1872     return $patterns;
1873 }
1874
1875 /**
1876  * Generates a default page type list when a more appropriate callback cannot be decided upon.
1877  *
1878  * @param string $pagetype
1879  * @param stdClass $parentcontext
1880  * @param stdClass $currentcontext
1881  * @return array
1882  */
1883 function default_page_type_list($pagetype, $parentcontext = null, $currentcontext = null) {
1884     // Generate page type patterns based on current page type if
1885     // callbacks haven't been defined
1886     $patterns = array($pagetype => $pagetype);
1887     $bits = explode('-', $pagetype);
1888     while (count($bits) > 0) {
1889         $pattern = implode('-', $bits) . '-*';
1890         $pagetypestringname = 'page-'.str_replace('*', 'x', $pattern);
1891         // guessing page type description
1892         if (get_string_manager()->string_exists($pagetypestringname, 'pagetype')) {
1893             $patterns[$pattern] = get_string($pagetypestringname, 'pagetype');
1894         } else {
1895             $patterns[$pattern] = $pattern;
1896         }
1897         array_pop($bits);
1898     }
1899     $patterns['*'] = get_string('page-x', 'pagetype');
1900     return $patterns;
1901 }
1902
1903 /**
1904  * Generates the page type list for the my moodle page
1905  *
1906  * @param string $pagetype
1907  * @param stdClass $parentcontext
1908  * @param stdClass $currentcontext
1909  * @return array
1910  */
1911 function my_page_type_list($pagetype, $parentcontext = null, $currentcontext = null) {
1912     return array('my-index' => get_string('page-my-index', 'pagetype'));
1913 }
1914
1915 /**
1916  * Generates the page type list for a module by either locating and using the modules callback
1917  * or by generating a default list.
1918  *
1919  * @param string $pagetype
1920  * @param stdClass $parentcontext
1921  * @param stdClass $currentcontext
1922  * @return array
1923  */
1924 function mod_page_type_list($pagetype, $parentcontext = null, $currentcontext = null) {
1925     $patterns = plugin_page_type_list($pagetype, $parentcontext, $currentcontext);
1926     if (empty($patterns)) {
1927         // if modules don't have callbacks
1928         // generate two default page type patterns for modules only
1929         $bits = explode('-', $pagetype);
1930         $patterns = array($pagetype => $pagetype);
1931         if ($bits[2] == 'view') {
1932             $patterns['mod-*-view'] = get_string('page-mod-x-view', 'pagetype');
1933         } else if ($bits[2] == 'index') {
1934             $patterns['mod-*-index'] = get_string('page-mod-x-index', 'pagetype');
1935         }
1936     }
1937     return $patterns;
1938 }
1939 /// Functions update the blocks if required by the request parameters ==========
1940
1941 /**
1942  * Return a {@link block_contents} representing the add a new block UI, if
1943  * this user is allowed to see it.
1944  *
1945  * @return block_contents an appropriate block_contents, or null if the user
1946  * cannot add any blocks here.
1947  */
1948 function block_add_block_ui($page, $output) {
1949     global $CFG, $OUTPUT;
1950     if (!$page->user_is_editing() || !$page->user_can_edit_blocks()) {
1951         return null;
1952     }
1953
1954     $bc = new block_contents();
1955     $bc->title = get_string('addblock');
1956     $bc->add_class('block_adminblock');
1957     $bc->attributes['data-block'] = 'adminblock';
1958
1959     $missingblocks = $page->blocks->get_addable_blocks();
1960     if (empty($missingblocks)) {
1961         $bc->content = get_string('noblockstoaddhere');
1962         return $bc;
1963     }
1964
1965     $menu = array();
1966     foreach ($missingblocks as $block) {
1967         $blockobject = block_instance($block->name);
1968         if ($blockobject !== false && $blockobject->user_can_addto($page)) {
1969             $menu[$block->name] = $blockobject->get_title();
1970         }
1971     }
1972     core_collator::asort($menu);
1973
1974     $actionurl = new moodle_url($page->url, array('sesskey'=>sesskey()));
1975     $select = new single_select($actionurl, 'bui_addblock', $menu, null, array(''=>get_string('adddots')), 'add_block');
1976     $select->set_label(get_string('addblock'), array('class'=>'accesshide'));
1977     $bc->content = $OUTPUT->render($select);
1978     return $bc;
1979 }
1980
1981 // Functions that have been deprecated by block_manager =======================
1982
1983 /**
1984  * @deprecated since Moodle 2.0 - use $page->blocks->get_addable_blocks();
1985  *
1986  * This function returns an array with the IDs of any blocks that you can add to your page.
1987  * Parameters are passed by reference for speed; they are not modified at all.
1988  *
1989  * @param $page the page object.
1990  * @param $blockmanager Not used.
1991  * @return array of block type ids.
1992  */
1993 function blocks_get_missing(&$page, &$blockmanager) {
1994     debugging('blocks_get_missing is deprecated. Please use $page->blocks->get_addable_blocks() instead.', DEBUG_DEVELOPER);
1995     $blocks = $page->blocks->get_addable_blocks();
1996     $ids = array();
1997     foreach ($blocks as $block) {
1998         $ids[] = $block->id;
1999     }
2000     return $ids;
2001 }
2002
2003 /**
2004  * Actually delete from the database any blocks that are currently on this page,
2005  * but which should not be there according to blocks_name_allowed_in_format.
2006  *
2007  * @todo Write/Fix this function. Currently returns immediately
2008  * @param $course
2009  */
2010 function blocks_remove_inappropriate($course) {
2011     // TODO
2012     return;
2013     /*
2014     $blockmanager = blocks_get_by_page($page);
2015
2016     if (empty($blockmanager)) {
2017         return;
2018     }
2019
2020     if (($pageformat = $page->pagetype) == NULL) {
2021         return;
2022     }
2023
2024     foreach($blockmanager as $region) {
2025         foreach($region as $instance) {
2026             $block = blocks_get_record($instance->blockid);
2027             if(!blocks_name_allowed_in_format($block->name, $pageformat)) {
2028                blocks_delete_instance($instance->instance);
2029             }
2030         }
2031     }*/
2032 }
2033
2034 /**
2035  * Check that a given name is in a permittable format
2036  *
2037  * @param string $name
2038  * @param string $pageformat
2039  * @return bool
2040  */
2041 function blocks_name_allowed_in_format($name, $pageformat) {
2042     $accept = NULL;
2043     $maxdepth = -1;
2044     if (!$bi = block_instance($name)) {
2045         return false;
2046     }
2047
2048     $formats = $bi->applicable_formats();
2049     if (!$formats) {
2050         $formats = array();
2051     }
2052     foreach ($formats as $format => $allowed) {
2053         $formatregex = '/^'.str_replace('*', '[^-]*', $format).'.*$/';
2054         $depth = substr_count($format, '-');
2055         if (preg_match($formatregex, $pageformat) && $depth > $maxdepth) {
2056             $maxdepth = $depth;
2057             $accept = $allowed;
2058         }
2059     }
2060     if ($accept === NULL) {
2061         $accept = !empty($formats['all']);
2062     }
2063     return $accept;
2064 }
2065
2066 /**
2067  * Delete a block, and associated data.
2068  *
2069  * @param object $instance a row from the block_instances table
2070  * @param bool $nolongerused legacy parameter. Not used, but kept for backwards compatibility.
2071  * @param bool $skipblockstables for internal use only. Makes @see blocks_delete_all_for_context() more efficient.
2072  */
2073 function blocks_delete_instance($instance, $nolongerused = false, $skipblockstables = false) {
2074     global $DB;
2075
2076     if ($block = block_instance($instance->blockname, $instance)) {
2077         $block->instance_delete();
2078     }
2079     context_helper::delete_instance(CONTEXT_BLOCK, $instance->id);
2080
2081     if (!$skipblockstables) {
2082         $DB->delete_records('block_positions', array('blockinstanceid' => $instance->id));
2083         $DB->delete_records('block_instances', array('id' => $instance->id));
2084         $DB->delete_records_list('user_preferences', 'name', array('block'.$instance->id.'hidden','docked_block_instance_'.$instance->id));
2085     }
2086 }
2087
2088 /**
2089  * Delete all the blocks that belong to a particular context.
2090  *
2091  * @param int $contextid the context id.
2092  */
2093 function blocks_delete_all_for_context($contextid) {
2094     global $DB;
2095     $instances = $DB->get_recordset('block_instances', array('parentcontextid' => $contextid));
2096     foreach ($instances as $instance) {
2097         blocks_delete_instance($instance, true);
2098     }
2099     $instances->close();
2100     $DB->delete_records('block_instances', array('parentcontextid' => $contextid));
2101     $DB->delete_records('block_positions', array('contextid' => $contextid));
2102 }
2103
2104 /**
2105  * Set a block to be visible or hidden on a particular page.
2106  *
2107  * @param object $instance a row from the block_instances, preferably LEFT JOINed with the
2108  *      block_positions table as return by block_manager.
2109  * @param moodle_page $page the back to set the visibility with respect to.
2110  * @param integer $newvisibility 1 for visible, 0 for hidden.
2111  */
2112 function blocks_set_visibility($instance, $page, $newvisibility) {
2113     global $DB;
2114     if (!empty($instance->blockpositionid)) {
2115         // Already have local information on this page.
2116         $DB->set_field('block_positions', 'visible', $newvisibility, array('id' => $instance->blockpositionid));
2117         return;
2118     }
2119
2120     // Create a new block_positions record.
2121     $bp = new stdClass;
2122     $bp->blockinstanceid = $instance->id;
2123     $bp->contextid = $page->context->id;
2124     $bp->pagetype = $page->pagetype;
2125     if ($page->subpage) {
2126         $bp->subpage = $page->subpage;
2127     }
2128     $bp->visible = $newvisibility;
2129     $bp->region = $instance->defaultregion;
2130     $bp->weight = $instance->defaultweight;
2131     $DB->insert_record('block_positions', $bp);
2132 }
2133
2134 /**
2135  * @deprecated since 2.0
2136  * Delete all the blocks from a particular page.
2137  *
2138  * @param string $pagetype the page type.
2139  * @param integer $pageid the page id.
2140  * @return bool success or failure.
2141  */
2142 function blocks_delete_all_on_page($pagetype, $pageid) {
2143     global $DB;
2144
2145     debugging('Call to deprecated function blocks_delete_all_on_page. ' .
2146             'This function cannot work any more. Doing nothing. ' .
2147             'Please update your code to use a block_manager method $PAGE->blocks->....', DEBUG_DEVELOPER);
2148     return false;
2149 }
2150
2151 /**
2152  * Get the block record for a particular blockid - that is, a particular type os block.
2153  *
2154  * @param $int blockid block type id. If null, an array of all block types is returned.
2155  * @param bool $notusedanymore No longer used.
2156  * @return array|object row from block table, or all rows.
2157  */
2158 function blocks_get_record($blockid = NULL, $notusedanymore = false) {
2159     global $PAGE;
2160     $blocks = $PAGE->blocks->get_installed_blocks();
2161     if ($blockid === NULL) {
2162         return $blocks;
2163     } else if (isset($blocks[$blockid])) {
2164         return $blocks[$blockid];
2165     } else {
2166         return false;
2167     }
2168 }
2169
2170 /**
2171  * Find a given block by its blockid within a provide array
2172  *
2173  * @param int $blockid
2174  * @param array $blocksarray
2175  * @return bool|object Instance if found else false
2176  */
2177 function blocks_find_block($blockid, $blocksarray) {
2178     if (empty($blocksarray)) {
2179         return false;
2180     }
2181     foreach($blocksarray as $blockgroup) {
2182         if (empty($blockgroup)) {
2183             continue;
2184         }
2185         foreach($blockgroup as $instance) {
2186             if($instance->blockid == $blockid) {
2187                 return $instance;
2188             }
2189         }
2190     }
2191     return false;
2192 }
2193
2194 // Functions for programatically adding default blocks to pages ================
2195
2196 /**
2197  * Parse a list of default blocks. See config-dist for a description of the format.
2198  *
2199  * @param string $blocksstr
2200  * @return array
2201  */
2202 function blocks_parse_default_blocks_list($blocksstr) {
2203     $blocks = array();
2204     $bits = explode(':', $blocksstr);
2205     if (!empty($bits)) {
2206         $leftbits = trim(array_shift($bits));
2207         if ($leftbits != '') {
2208             $blocks[BLOCK_POS_LEFT] = explode(',', $leftbits);
2209         }
2210     }
2211     if (!empty($bits)) {
2212         $rightbits =trim(array_shift($bits));
2213         if ($rightbits != '') {
2214             $blocks[BLOCK_POS_RIGHT] = explode(',', $rightbits);
2215         }
2216     }
2217     return $blocks;
2218 }
2219
2220 /**
2221  * @return array the blocks that should be added to the site course by default.
2222  */
2223 function blocks_get_default_site_course_blocks() {
2224     global $CFG;
2225
2226     if (!empty($CFG->defaultblocks_site)) {
2227         return blocks_parse_default_blocks_list($CFG->defaultblocks_site);
2228     } else {
2229         return array(
2230             BLOCK_POS_LEFT => array('site_main_menu'),
2231             BLOCK_POS_RIGHT => array('course_summary', 'calendar_month')
2232         );
2233     }
2234 }
2235
2236 /**
2237  * Add the default blocks to a course.
2238  *
2239  * @param object $course a course object.
2240  */
2241 function blocks_add_default_course_blocks($course) {
2242     global $CFG;
2243
2244     if (!empty($CFG->defaultblocks_override)) {
2245         $blocknames = blocks_parse_default_blocks_list($CFG->defaultblocks_override);
2246
2247     } else if ($course->id == SITEID) {
2248         $blocknames = blocks_get_default_site_course_blocks();
2249
2250     } else if (!empty($CFG->{'defaultblocks_' . $course->format})) {
2251         $blocknames = blocks_parse_default_blocks_list($CFG->{'defaultblocks_' . $course->format});
2252
2253     } else {
2254         require_once($CFG->dirroot. '/course/lib.php');
2255         $blocknames = course_get_format($course)->get_default_blocks();
2256
2257     }
2258
2259     if ($course->id == SITEID) {
2260         $pagetypepattern = 'site-index';
2261     } else {
2262         $pagetypepattern = 'course-view-*';
2263     }
2264     $page = new moodle_page();
2265     $page->set_course($course);
2266     $page->blocks->add_blocks($blocknames, $pagetypepattern);
2267 }
2268
2269 /**
2270  * Add the default system-context blocks. E.g. the admin tree.
2271  */
2272 function blocks_add_default_system_blocks() {
2273     global $DB;
2274
2275     $page = new moodle_page();
2276     $page->set_context(context_system::instance());
2277     $page->blocks->add_blocks(array(BLOCK_POS_LEFT => array('navigation', 'settings')), '*', null, true);
2278     $page->blocks->add_blocks(array(BLOCK_POS_LEFT => array('admin_bookmarks')), 'admin-*', null, null, 2);
2279
2280     if ($defaultmypage = $DB->get_record('my_pages', array('userid'=>null, 'name'=>'__default', 'private'=>1))) {
2281         $subpagepattern = $defaultmypage->id;
2282     } else {
2283         $subpagepattern = null;
2284     }
2285
2286     $page->blocks->add_blocks(array(BLOCK_POS_RIGHT => array('private_files', 'online_users'), 'content' => array('course_overview')), 'my-index', $subpagepattern, false);
2287 }