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