Proyectos de Subversion Moodle

<?php

// This file is part of Moodle - http://moodle.org/

//

// Moodle is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// Moodle is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

/**

 * Class that does all the magic.

 *

 * @package   block_multiblock

 * @copyright 2019 Peter Spicer <peter.spicer@catalyst-eu.net> 2021 James Pearce <jmp201@bath.ac.uk>

 * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

use block_multiblock\helper;

use block_multiblock\icon_helper;

use block_multiblock\adddefaultblock;

/**

 * Block multiblock class definition.

 *

 * This block can be added to a variety of places to display multiple blocks in one space.

 *

 * @package   block_multiblock

 * @copyright 2019 Peter Spicer <peter.spicer@catalyst-eu.net>

 * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

class block_multiblock extends block_base

{

    /** @var object $output Temporary storage of the injected page renderer so we can pass it to child blocks at render time. */

    private $output;

    /**

     * Core function used to initialize the block.

     */

    public function init()

    {

        $this->title = get_string('pluginname', 'block_multiblock');

    }

    /**

     * has_config - denotes whether your block wants to present a configuration interface to site admins or not

     *

     * @return boolean

     */

    public function has_config()

    {

        return true;

    }

    /**

     * Core function, specifies where the block can be used.

     *

     * @return array

     */

    public function applicable_formats()

    {

        return [

            'all' => true,

        ];

    }

    /**

     * Sets the block's title for a specific instance based on its configuration.

     */

    public function specialization()

    {

        $defaulttitle = get_config('block_multiblock', 'title');

        if (isset($this->config->title)) {

            $this->title = format_string($this->config->title, true, ['context' => $this->context]);

        } else if ($defaulttitle) {

            $this->title = format_string($defaulttitle, true, ['context' => $this->context]);

        } else {

            $this->title = get_string('pluginname', 'block_multiblock');

        }

    }

    /* Set block attributes */

    function html_attributes()

    {

        $attributes = array(

            'id' => 'inst' . $this->instance->id,

            'class' => 'block_' . $this->name() . ' block' . ' multiblock-columns-2-parent',

            'role' => $this->get_aria_role()

        );

        if ($this->hide_header()) {

            $attributes['class'] .= ' no-header';

        }

        if ($this->instance_can_be_docked() && get_user_preferences('docked_block_instance_' . $this->instance->id, 0)) {

            $attributes['class'] .= ' dock_on_load';

        }

        return $attributes;

    }

    /**

     * Loads the child blocks of the current multiblock.

     *

     * @param int $contextid The multiblock's context instance id.

     * @return array An array of child blocks.

     */

    public function load_multiblocks($contextid)

    {

        global $DB;

        // Find all the things that relate to this block.

        $this->blocks = $DB->get_records('block_instances', ['parentcontextid' => $contextid], 'defaultweight, id');

        foreach ($this->blocks as $id => $block) {

            if (block_load_class($block->blockname)) {

                // Make the proxy class we'll need.

                $this->blocks[$id]->blockinstance = block_instance($block->blockname, $block);

                $this->blocks[$id]->blockname = $block->blockname;

                $this->blocks[$id]->visible = true;

                $this->blocks[$id]->blockpositionid = 0;

            }

        }

        return $this->blocks;

    }

    /**

     *  Used to add the default blocks to the multiblock.

     */

    public function add_default_blocks()

    {

        global $DB, $CFG;

        if (empty($this->instance)) {

            return $this->content;

        }

        $context = $DB->get_record('context', ['contextlevel' => CONTEXT_BLOCK, 'instanceid' => $this->instance->id]);

        $this->load_multiblocks($context->id);

        $multiblock = [];

        $isodd = true;

        $blockid = $this->instance->id;

        if (empty($this->blocks)) {

            $defaultblocksarray = explode(',', get_config('block_multiblock')->subblock);

            $addblock = new adddefaultblock();

            $addblock->init($blockid, $defaultblocksarray, $this->instance);

        }

    }

    /**

     * Used to generate the content for the block.

     *

     * @return string

     */

    public function get_content()

    {

        global $DB, $CFG;

        if ($this->content !== null) {

            return $this->content;

        }

        $this->content = new stdClass;

        $this->content->text = '';

        $this->content->footer = '';

        if (empty($this->instance)) {

            return $this->content;

        }

        $context = $DB->get_record('context', ['contextlevel' => CONTEXT_BLOCK, 'instanceid' => $this->instance->id]);

        $this->load_multiblocks($context->id);

        $multiblock = [];

        $isodd = true;

        $blockid = $this->instance->id;

        if (empty($this->blocks)) {

            $this->add_default_blocks();

            $this->load_multiblocks($context->id);

        }

        foreach ($this->blocks as $id => $block) {

            if (empty($block->blockinstance)) {

                continue;

            }

            $content = $block->blockinstance->get_content_for_output($this->output);

            $multiblock[] = [

                'id' => $id,

                'class' => 'block_' . $block->blockinstance->name(),

                'type' => $block->blockinstance->name(),

                'is_odd' => $isodd,

                'title' => $block->blockinstance->get_title(),

                'content' => !empty($content->content) ? $content->content : '',

                'footer' => !empty($content->footer) ? $content->footer : '',

            ];

            $isodd = !$isodd;

        }

        $template = '';

        $presentations = static::get_valid_presentations();

        $multiblockpresentationoptions = [];

        foreach ($presentations as $presentationid => $presentation) {

            array_push($multiblockpresentationoptions, $presentationid);

        }

        $configuredpresentation = get_config('block_multiblock', 'presentation');

        if (!empty($this->config->presentation)) {

            $template = $this->config->presentation;

        } else if (isset($configuredpresentation)) {

            $template = $multiblockpresentationoptions[$configuredpresentation];

        } else if (isset($presentations['tabbed-list'])) {

            $template = 'tabbed-list';

        }

        $renderable = new \block_multiblock\output\main((int) $this->instance->id, $multiblock, $template);

        $renderer = $this->page->get_renderer('block_multiblock');

        $this->content = (object) [

            'text' => $renderer->render($renderable),

            'footer' => ''

        ];

        return $this->content;

    }

    /**

     * Return a block_contents object representing the full contents of this block.

     *

     * This internally calls ->get_content(), and then adds the editing controls etc.

     *

     * @param object $output The output renderer from the parent context (e.g. page renderer)

     * @return block_contents a representation of the block, for rendering.

     */

    public function get_content_for_output($output)

    {

        $this->output = $output;

        $bc = parent::get_content_for_output($output);

        if (empty($bc->controls)) {

            return $bc;

        }

        $str = get_string('managemultiblock', 'block_multiblock', $this->title);

        $newcontrols = [];

        foreach ($bc->controls as $control) {

            $newcontrols[] = $control;

            // Append our new item onto the controls if we're on the correct item.

            if (strpos($control->attributes['class'], 'editing_edit') !== false) {

                $newcontrols[] = new action_menu_link_secondary(

                    new moodle_url('/blocks/multiblock/manage.php', ['id' => $this->instance->id, 'sesskey' => sesskey()]),

                    icon_helper::preferences($str),

                    $str,

                    ['class' => 'editing_manage']

                );

            }

        }

        // Append a delete+split item on the end.

        $newcontrols[] = new action_menu_link_secondary(

            new moodle_url('/blocks/multiblock/manage.php', [

                'id' => $this->instance->id,

                'sesskey' => sesskey(),

                'action' => 'splitdelete'

            ]),

            icon_helper::delete($str),

            get_string('splitanddelete', 'block_multiblock', $this->title),

            ['class' => 'editing_manage']

        );

        $bc->controls = $newcontrols;

        return $bc;

    }

    /**

     * Allows the block to be added multiple times to a single page

     * @return boolean

     */

    public function instance_allow_multiple()

    {

        return true;

    }

    /**

     * Copy all the children when copying to a new block instance.

     *

     * @param int $fromid The id number of the block instance to copy from

     * @return bool

     */

    public function instance_copy($fromid)

    {

        global $DB;

        $fromcontext = context_block::instance($fromid);

        $blockinstances = $DB->get_records('block_instances', ['parentcontextid' => $fromcontext->id], 'defaultweight, id');

        // Create all the new block instances.

        $newblockinstanceids = [];

        foreach ($blockinstances as $instance) {

            $originalid = $instance->id;

            unset($instance->id);

            $instance->parentcontextid = $this->context->id;

            $instance->timecreated = time();

            $instance->timemodified = $instance->timecreated;

            $instance->id = $DB->insert_record('block_instances', $instance);

            $newblockinstanceids[$originalid] = $instance->id;

            $blockcontext = context_block::instance($instance->id);  // Just creates the context record.

            $block = block_instance($instance->blockname, $instance);

            if (!$block->instance_copy($originalid)) {

                debugging("Unable to copy block-specific data for original block instance: $originalid

                    to new block instance: $instance->id", DEBUG_DEVELOPER);

            }

        }

        return true;

    }

    /**

     * Callback for when this block instance is being deleted, to clean up child blocks.

     *

     * @return bool

     */

    public function instance_delete()

    {

        global $DB;

        // Find all the things that relate to this block.

        foreach ($DB->get_records('block_instances', ['parentcontextid' => $this->context->id]) as $subblock) {

            blocks_delete_instance($subblock);

        }

        return true;

    }

    /**

     * Lists all the known presentation types that exist in the block.

     *

     * @return array An array of presentations for block rendering.

     */

    public static function get_valid_presentations(): array

    {

        static $presentations = null;

        if ($presentations === null) {

            foreach (core_component::get_component_classes_in_namespace('block_multiblock', 'layout') as $class => $ns) {

                if (strpos($class, $ns[0]) === 0) {

                    // We only care about non-abstract classes here.

                    $reflection = new ReflectionClass($class);

                    if ($reflection->isAbstract()) {

                        continue;

                    }

                    $classname = substr($class, strlen($ns[0]));

                    $instance = new $class;

                    $presentations[$instance->get_layout_id()] = $instance;

                }

            }

        }

        return $presentations;

    }

    /**

     * Returns the default presentation for the multiblock.

     *

     * @return string The default presentation's identifier.

     */

    public static function get_default_presentation(): string

    {

        $presentations = static::get_valid_presentations();

        $multiblockpresentationoptions = [];

        $configuredpresentation = get_config('block_multiblock', 'presentation');

        foreach ($presentations as $presentationid => $presentation) {

            array_push($multiblockpresentationoptions, $presentationid);

        }

        if ($configuredpresentation) {

            return $multiblockpresentationoptions[$configuredpresentation];

        }

        // Our expected default is not present, make sure we fall back to something.

        return array_keys($presentations)[0];

    }

}