C:/xampp/htdocs/moodle/backup/util/ui/backup_ui_setting.class.php

Go to the documentation of this file.

<?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 base_setting_ui {
    const NAME_PREFIX = 'setting_';
    protected $name;
    protected $label;
    protected $attributes = array();
    protected $type;
    protected $icon = false;
    protected $setting;
    public function __construct(base_setting $setting) {
        $this->setting = $setting;
    }

    public function destroy() {
        // No need to destroy anything recursively here, direct reset
        $this->setting = null;
    }

    public function get_name() {
        return self::NAME_PREFIX.$this->name;
    }
    public function get_label() {
        return $this->label;
    }
    public function get_type() {
        return $this->type;
    }
    public function get_attributes() {
        return $this->attributes;
    }
    public function get_value() {
        return $this->setting->get_value();
    }
    public function get_static_value() {
        return $this->setting->get_value();
    }
    public function set_label($label) {
        if (empty($label) || $label !== clean_param($label, PARAM_TEXT)) {
            throw new base_setting_ui_exception('setting_invalid_ui_label');
        }
        $this->label = $label;
    }
    public function disable() {
       $this->attributes['disabled'] = 'disabled';
    }

    public function set_icon(pix_icon $icon) {
        $this->icon = $icon;
    }

    public function get_icon() {
        if (!empty($this->icon)) {
            return $this->icon;
        }
        return false;
    }
}

abstract class backup_setting_ui extends base_setting_ui {
    protected $options = array();

    public function __construct(backup_setting $setting, $label = null, array $attributes = null, array $options = null) {
        parent::__construct($setting);
        // Improve the inputs name by appending the level to the name
        switch ($setting->get_level()) {
            case backup_setting::ROOT_LEVEL :
                $this->name = 'root_'.$setting->get_name();
                break;
            case backup_setting::COURSE_LEVEL :
                $this->name = 'course_'.$setting->get_name();
                break;
            case backup_setting::SECTION_LEVEL :
                $this->name = 'section_'.$setting->get_name();
                break;
            case backup_setting::ACTIVITY_LEVEL :
                $this->name = 'activity_'.$setting->get_name();
                break;
        }
        $this->label = $label;
        if (is_array($attributes)) {
            $this->attributes = $attributes;
        }
        if (is_array($options)) {
            $this->options = $options;
        }
    }
    final public static function make(backup_setting $setting, $type, $label, array $attributes = null, array $options=null) {
        // Base the decision we make on the type that was sent
        switch ($type) {
            case backup_setting::UI_HTML_CHECKBOX :
                return new backup_setting_ui_checkbox($setting, $label, null, (array)$attributes, (array)$options);
            case backup_setting::UI_HTML_DROPDOWN :
                return new backup_setting_ui_select($setting, $label, null, (array)$attributes, (array)$options);
            case backup_setting::UI_HTML_RADIOBUTTON :
                return new backup_setting_ui_radio($setting, $label, null, null, (array)$attributes, (array)$options);
            case backup_setting::UI_HTML_TEXTFIELD :
                return new backup_setting_ui_text($setting, $label, $attributes, $options);
            default:
                throw new backup_setting_ui_exception('setting_invalid_ui_type');
        }
    }
    abstract public function get_element_properties(base_task $task=null, renderer_base $output=null);
    public function apply_options(array $properties) {
        if (!empty($this->options['size'])) {
            $properties['attributes']['size'] = $this->options['size'];
        }
        return $properties;
    }
    public function get_label(base_task $task=null) {
        // If a task has been provided and the label is not already set meaniningfully
        // we will attempt to improve it.
        if (!is_null($task) && $this->label == $this->setting->get_name() && strpos($this->setting->get_name(), '_include')!==false) {
            if ($this->setting->get_level() == backup_setting::SECTION_LEVEL) {
                $this->label = get_string('includesection', 'backup', $task->get_name());
            } else if ($this->setting->get_level() == backup_setting::ACTIVITY_LEVEL) {
                $this->label = $task->get_name();
            }
        }
        return $this->label;
    }
    public function is_changeable() {
        if ($this->setting->get_status() === backup_setting::NOT_LOCKED) {
            // Its not locked so its chanegable
            return true;
        } else if ($this->setting->get_status() !== backup_setting::LOCKED_BY_HIERARCHY) {
            // Its not changeable because its locked by permission or config
            return false;
        } else if ($this->setting->has_dependencies_on_settings()) {
            foreach ($this->setting->get_settings_depended_on() as $dependency) {
                if ($dependency->is_locked() && $dependency->get_setting()->get_level() !== $this->setting->get_level()) {
                    // Its not changeable because one or more dependancies arn't
                    // changeable.
                   return false;
                }
            }
            // Its changeable because all dependencies are changeable.
            return true;
        }
        // We should never get here but if we do return false to be safe.
        // The setting would need to be locked by hierarchy and not have any deps
        return false;
    }

}

class backup_setting_ui_text extends backup_setting_ui {
    protected $type = backup_setting::UI_HTML_TEXTFIELD;
    public function get_element_properties(base_task $task=null, renderer_base $output=null) {
        // name, label, text, attributes
        $icon = $this->get_icon();
        $label = $this->get_label($task);
        if (!empty($icon)) {
            $label .= '&nbsp;'.$output->render($icon);
        }
        // name, label, attributes
        return $this->apply_options(array('element'=>'text','name'=>self::NAME_PREFIX.$this->name, 'label'=>$label, 'attributes'=>$this->attributes));
    }

}

class backup_setting_ui_checkbox extends backup_setting_ui {
    protected $type = backup_setting::UI_HTML_CHECKBOX;
    protected $changeable = true;
    protected $text;
    public function __construct(backup_setting $setting, $label = null, $text=null, array $attributes = array(), array $options = array()) {
        parent::__construct($setting, $label, $attributes, $options);
        $this->text = $text;
    }
    public function get_element_properties(base_task $task=null, renderer_base $output=null) {
        // name, label, text, attributes

        $icon = $this->get_icon();
        $label = $this->get_label($task);
        if (!empty($icon)) {
            $label .= '&nbsp;'.$output->render($icon);
        }
        return $this->apply_options(array('element'=>'checkbox','name'=>self::NAME_PREFIX.$this->name, 'label'=>$label, 'text'=>$this->text, 'attributes'=>$this->attributes));
    }
    public function set_text($text) {
        $this->text = $text;
    }
    public function get_static_value() {
        global $OUTPUT;
        // Checkboxes are always yes or no
        if ($this->get_value()) {
            return $OUTPUT->pix_icon('i/tick_green_big', get_string('yes'));
        } else {
            return $OUTPUT->pix_icon('i/cross_red_big', get_string('no'));
        }
    }

    public function is_changeable() {
        if ($this->changeable===false) {
            return false;
        } else {
            return parent::is_changeable();
        }
    }

    public function set_changeable($newvalue) {
        $this->changeable = ($newvalue);
    }
}

class backup_setting_ui_radio extends backup_setting_ui {
    protected $type = backup_setting::UI_HTML_RADIOBUTTON;
    protected $text;
    protected $value;
    public function __construct(backup_setting $setting, $label = null, $text=null, $value=null, array $attributes = array(), array $options = array()) {
        parent::__construct($setting, $label, $attributes, $options);
        $this->text = $text;
        $this->value = (string)$value;
    }
    public function get_element_properties(base_task $task=null, renderer_base $output=null) {
        // name, label, text, attributes
        $icon = $this->get_icon();
        $label = $this->get_label($task);
        if (!empty($icon)) {
            $label .= '&nbsp;'.$output->render($icon);
        }
        // name, label, text, value, attributes
        return $this->apply_options(array('element'=>'radio','name'=>self::NAME_PREFIX.$this->name, 'label'=>$label, 'text'=>$this->text, 'value'=>$this->value, 'attributes'=>$this->attributes));
    }
    public function set_text($text) {
        $this->text = $text;
    }
    public function set_value($value) {
        $this->value = (string)$value;
    }
    public function get_static_value() {
        return $this->value;
    }
}

class backup_setting_ui_select extends backup_setting_ui {
    protected $type = backup_setting::UI_HTML_DROPDOWN;
    protected $values;
    public function __construct(backup_setting $setting, $label = null, $values=null, array $attributes = array(), array $options = array()) {
        parent::__construct($setting, $label, $attributes, $options);
        $this->values = $values;
    }
    public function get_element_properties(base_task $task = null, renderer_base $output=null) {
        // name, label, text, attributes
        $icon = $this->get_icon();
        $label = $this->get_label($task);
        if (!empty($icon)) {
            $label .= '&nbsp;'.$output->render($icon);
        }
        // name, label, options, attributes
        return $this->apply_options(array('element'=>'select','name'=>self::NAME_PREFIX.$this->name, 'label'=>$label, 'options'=>$this->values, 'attributes'=>$this->attributes));
    }
    public function set_values(array $values) {
        $this->values = $values;
    }
    public function get_static_value() {
        return $this->values[$this->get_value()];
    }
    public function is_changeable() {
        if (count($this->values) == 1) {
            return false;
        } else {
            return parent::is_changeable();
        }
    }
}

class backup_setting_ui_dateselector extends backup_setting_ui_text {
    public function get_element_properties(base_task $task = null, renderer_base $output=null) {
        if (!array_key_exists('optional', $this->attributes)) {
            $this->attributes['optional'] = false;
        }
        $properties = parent::get_element_properties($task, $output);
        $properties['element'] = 'date_selector';
        return $properties;
    }
    public function get_static_value() {
        $value = $this->get_value();
        if (!empty($value)) {
            return userdate($value);
        }
        return parent::get_static_value();
    }
}

class base_setting_ui_exception extends base_setting_exception {}
class backup_setting_ui_exception extends base_setting_ui_exception {};