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/>.

namespace core_courseformat\output\local\content;

use core\context\course as context_course;

use core\output\action_menu;

use core\output\action_menu\link_secondary;

use core\output\named_templatable;

use core\output\pix_icon;

use core\output\renderable;

use core\output\renderer_base;

use core_courseformat\base as course_format;

use core_courseformat\output\local\courseformat_named_templatable;

use core\url;

use section_info;

use cm_info;

use stdClass;

/**

 * Base class to render course element controls.

 *

 * @package   core_courseformat

 * @copyright 2024 Amaia Anabitarte <amaia@moodle.com>

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

 */

abstract class basecontrolmenu implements named_templatable, renderable {

    use courseformat_named_templatable;

    /** @var course_format the course format class */

    protected $format;

    /** @var section_info the course section class */

    protected $section;

    /** @var cm_info the course module class */

    protected $mod;

    /** @var stdClass the course instance */

    protected stdClass $course;

    /** @var context_course the course context */

    protected $coursecontext;

    /** @var string the menu ID */

    protected $menuid;

    /** @var action_menu the action menu */

    protected $menu;

    /** @var url The base URL for the course or the section */

    protected url $baseurl;

    /**

     * Constructor.

     *

     * @param course_format $format the course format

     * @param section_info $section the section info

     * @param cm_info|null $mod the module info

     * @param string $menuid the ID value for the menu

     */

    public function __construct(course_format $format, section_info $section, ?cm_info $mod = null, string $menuid = '') {

        $this->format = $format;

        $this->section = $section;

        $this->mod = $mod;

        $this->menuid = $menuid;

        $this->course = $format->get_course();

        $this->coursecontext = $format->get_context();

        $this->baseurl = $format->get_view_url($format->get_sectionnum(), ['navigation' => true]);

    }

    /**

     * Change the default base URL to return after each action.

     *

     * @param url $baseurl

     */

    public function set_baseurl(url $baseurl) {

        $this->baseurl = $baseurl;

    }

    /**

     * Export this data so it can be used as the context for a mustache template.

     *

     * @param renderer_base $output typically, the renderer that's calling this function

     * @return null|array data context for a mustache template

     */

    public function export_for_template(renderer_base $output): ?stdClass {

        $menu = $this->get_action_menu($output);

        if (empty($menu)) {

            return new stdClass();

        }

        $data = (object)[

            'menu' => $output->render($menu),

            'hasmenu' => true,

            'id' => $this->menuid,

        ];

        return $data;

    }

    /**

     * Generate the action menu element.

     *

     * @param renderer_base $output typically, the renderer that's calling this function

     * @return action_menu|null the action menu or null if no action menu is available

     */

    public function get_action_menu(renderer_base $output): ?action_menu {

        if (!empty($this->menu)) {

            return $this->menu;

        }

        $this->menu = $this->get_default_action_menu($output);

        return $this->menu;

    }

    /**

     * Generate the default action menu.

     *

     * This method is public in case some block needs to modify the menu before output it.

     *

     * @param renderer_base $output typically, the renderer that's calling this function

     * @return action_menu|null the action menu

     */

    public function get_default_action_menu(renderer_base $output): ?action_menu {

        return null;

    }

    /**

     * Format control array into an action_menu.

     *

     * @param \renderer_base $output typically, the renderer that's calling this function

     * @return action_menu|null the action menu

     */

    protected function format_controls(array $controls): ?action_menu {

        if (empty($controls)) {

            return null;

        }

        $menu = new action_menu();

        $menu->set_kebab_trigger(get_string('edit'));

        $menu->attributes['class'] .= ' section-actions';

        $menu->attributes['data-sectionid'] = $this->section->id;

        foreach ($controls as $item) {

            // Actions not available for the user can be null.

            if ($item === null) {

                continue;

            }

            // TODO remove this if as part of MDL-83530.

            if (is_array($item)) {

                // Some third party formats from 4.5 and older can use array to define the action menu items.

                $item = $this->normalize_action_menu_link($item);

            }

            $menu->add($item);

        }

        return $menu;

    }

    /**

     * Nromalize the action menu item, or return null if it is not possible.

     *

     * Traditionally, this class uses array to define the action menu items,

     * for backward compatibility, this method will normalize the array into

     * the correct action_menu_link object.

     *

     * @todo Remove this method in Moodle 6.0 (MDL-83530).

     * @param array|null $itemdata the item data

     * @return void

     */

    private function normalize_action_menu_link(

        array|null $itemdata

    ): ?link_secondary {

        debugging(

            "Using arrays as action menu items is deprecated, use a compatible menu item instead.",

            DEBUG_DEVELOPER

        );

        if (empty($itemdata)) {

            return null;

        }

        $url = empty($itemdata['url']) ? '' : $itemdata['url'];

        $icon = empty($itemdata['icon']) ? '' : $itemdata['icon'];

        $name = empty($itemdata['name']) ? '' : $itemdata['name'];

        $attr = empty($itemdata['attr']) ? [] : $itemdata['attr'];

        $class = empty($itemdata['pixattr']['class']) ? '' : $itemdata['pixattr']['class'];

        return new link_secondary(

            url: new url($url),

            icon: new pix_icon($icon, '', null, ['class' => "smallicon " . $class]),

            text: $name,

            attributes: $attr,

        );

    }

    /**

     * Generate the edit control items of a section.

     *

     * This method must remain public until the final deprecation of section_edit_control_items.

     *

     * @return array of edit control items

     */

    public function section_control_items() {

        return [];

    }

    /**

     * Adds a new control item after a given control item.

     *

     * If the control item is not found, the new control item is added at the beginning.

     *

     * @param array $controls array of edit control items

     * @param string $aftername name of the control item after which the new control item will be added

     * @param string $newkey key of the new control item

     * @param mixed $newcontrol new control item to be added (anything compatible with an action menu or null)

     */

    protected function add_control_after(array $controls, string $aftername, string $newkey, mixed $newcontrol): array {

        if (!array_key_exists($aftername, $controls)) {

            return array_merge([$newkey => $newcontrol], $controls);

        }

        $newcontrols = [];

        $found = false;

        foreach ($controls as $keyname => $control) {

            $newcontrols[$keyname] = $control;

            if ($keyname === $aftername) {

                $newcontrols[$newkey] = $newcontrol;

                $found = true;

            }

        }

        if (!$found) {

            $newcontrols[$newkey] = $newcontrol;

        }

        return $newcontrols;

    }

}