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