Mikel Martín
04975cd2b2
- .custom-check is now .form-check. - .custom-check.custom-switch is now .form-check.form-switch. - .custom-select is now .form-select. - .custom-file and .form-file have been replaced by custom styles on top of .form-control. - .custom-range is now .form-range. - Dropped .input-group-append and .input-group-prepend. You can now just add buttons and .input-group-text as direct children of the input groups.
899 lines
34 KiB
PHP
899 lines
34 KiB
PHP
<?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\output;
|
|
|
|
use core\exception\coding_exception;
|
|
use core_table\output\html_table;
|
|
use core_table\output\html_table_cell;
|
|
use core_table\output\html_table_row;
|
|
use core_text;
|
|
use moodle_url;
|
|
|
|
/**
|
|
* Simple html output class
|
|
*
|
|
* @copyright 2009 Tim Hunt, 2010 Petr Skoda
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
* @since Moodle 2.0
|
|
* @package core
|
|
* @category output
|
|
*/
|
|
class html_writer {
|
|
/**
|
|
* Outputs a tag with attributes and contents
|
|
*
|
|
* @param string $tagname The name of tag ('a', 'img', 'span' etc.)
|
|
* @param string $contents What goes between the opening and closing tags
|
|
* @param null|array $attributes The tag attributes (array('src' => $url, 'class' => 'class1') etc.)
|
|
* @return string HTML fragment
|
|
*/
|
|
public static function tag($tagname, $contents, ?array $attributes = null) {
|
|
return self::start_tag($tagname, $attributes) . $contents . self::end_tag($tagname);
|
|
}
|
|
|
|
/**
|
|
* Outputs an opening tag with attributes
|
|
*
|
|
* @param string $tagname The name of tag ('a', 'img', 'span' etc.)
|
|
* @param null|array $attributes The tag attributes (array('src' => $url, 'class' => 'class1') etc.)
|
|
* @return string HTML fragment
|
|
*/
|
|
public static function start_tag($tagname, ?array $attributes = null) {
|
|
return '<' . $tagname . self::attributes($attributes) . '>';
|
|
}
|
|
|
|
/**
|
|
* Outputs a closing tag
|
|
*
|
|
* @param string $tagname The name of tag ('a', 'img', 'span' etc.)
|
|
* @return string HTML fragment
|
|
*/
|
|
public static function end_tag($tagname) {
|
|
return '</' . $tagname . '>';
|
|
}
|
|
|
|
/**
|
|
* Outputs an empty tag with attributes
|
|
*
|
|
* @param string $tagname The name of tag ('input', 'img', 'br' etc.)
|
|
* @param null|array $attributes The tag attributes (array('src' => $url, 'class' => 'class1') etc.)
|
|
* @return string HTML fragment
|
|
*/
|
|
public static function empty_tag($tagname, ?array $attributes = null) {
|
|
return '<' . $tagname . self::attributes($attributes) . ' />';
|
|
}
|
|
|
|
/**
|
|
* Outputs a tag, but only if the contents are not empty
|
|
*
|
|
* @param string $tagname The name of tag ('a', 'img', 'span' etc.)
|
|
* @param string $contents What goes between the opening and closing tags
|
|
* @param null|array $attributes The tag attributes (array('src' => $url, 'class' => 'class1') etc.)
|
|
* @return string HTML fragment
|
|
*/
|
|
public static function nonempty_tag($tagname, $contents, ?array $attributes = null) {
|
|
if ($contents === '' || is_null($contents)) {
|
|
return '';
|
|
}
|
|
return self::tag($tagname, $contents, $attributes);
|
|
}
|
|
|
|
/**
|
|
* Outputs a HTML attribute and value
|
|
*
|
|
* @param string $name The name of the attribute ('src', 'href', 'class' etc.)
|
|
* @param string $value The value of the attribute. The value will be escaped with {@see s()}
|
|
* @return string HTML fragment
|
|
*/
|
|
public static function attribute($name, $value) {
|
|
if ($value instanceof moodle_url) {
|
|
return ' ' . $name . '="' . $value->out() . '"';
|
|
}
|
|
|
|
// Special case, we do not want these in output.
|
|
if ($value === null) {
|
|
return '';
|
|
}
|
|
|
|
// No sloppy trimming here!
|
|
return ' ' . $name . '="' . s($value) . '"';
|
|
}
|
|
|
|
/**
|
|
* Outputs a list of HTML attributes and values
|
|
*
|
|
* @param null|array $attributes The tag attributes (array('src' => $url, 'class' => 'class1') etc.)
|
|
* The values will be escaped with {@see s()}
|
|
* @return string HTML fragment
|
|
*/
|
|
public static function attributes(?array $attributes = null) {
|
|
$attributes = (array)$attributes;
|
|
$output = '';
|
|
foreach ($attributes as $name => $value) {
|
|
$output .= self::attribute($name, $value);
|
|
}
|
|
return $output;
|
|
}
|
|
|
|
/**
|
|
* Generates a simple image tag with attributes.
|
|
*
|
|
* @param string $src The source of image
|
|
* @param string $alt The alternate text for image
|
|
* @param null|array $attributes The tag attributes (array('height' => $max_height, 'class' => 'class1') etc.)
|
|
* @return string HTML fragment
|
|
*/
|
|
public static function img($src, $alt, ?array $attributes = null) {
|
|
$attributes = (array)$attributes;
|
|
$attributes['src'] = $src;
|
|
// In case a null alt text is provided, set it to an empty string.
|
|
$attributes['alt'] = $alt ?? '';
|
|
if (array_key_exists('role', $attributes) && core_text::strtolower($attributes['role']) === 'presentation') {
|
|
// A presentation role is not necessary for the img tag.
|
|
// If a non-empty alt text is provided, the presentation role will conflict with the alt text.
|
|
// An empty alt text denotes a decorative image. The presence of a presentation role is redundant.
|
|
unset($attributes['role']);
|
|
debugging('The presentation role is not necessary for an img tag.', DEBUG_DEVELOPER);
|
|
}
|
|
|
|
return self::empty_tag('img', $attributes);
|
|
}
|
|
|
|
/**
|
|
* Generates random html element id.
|
|
*
|
|
* @staticvar int $counter
|
|
* @staticvar string $uniq
|
|
* @param string $base A string fragment that will be included in the random ID.
|
|
* @return string A unique ID
|
|
*/
|
|
public static function random_id($base = 'random') {
|
|
static $counter = 0;
|
|
static $uniq;
|
|
|
|
if (!isset($uniq)) {
|
|
$uniq = uniqid();
|
|
}
|
|
|
|
$counter++;
|
|
return $base . $uniq . $counter;
|
|
}
|
|
|
|
/**
|
|
* Generates a simple html link
|
|
*
|
|
* @param string|moodle_url $url The URL
|
|
* @param string $text The text
|
|
* @param null|array $attributes HTML attributes
|
|
* @return string HTML fragment
|
|
*/
|
|
public static function link($url, $text, ?array $attributes = null) {
|
|
$attributes = (array)$attributes;
|
|
$attributes['href'] = $url;
|
|
return self::tag('a', $text, $attributes);
|
|
}
|
|
|
|
/**
|
|
* Generates a simple checkbox with optional label
|
|
*
|
|
* @param string $name The name of the checkbox
|
|
* @param string $value The value of the checkbox
|
|
* @param bool $checked Whether the checkbox is checked
|
|
* @param string $label The label for the checkbox
|
|
* @param null|array $attributes Any attributes to apply to the checkbox
|
|
* @param null|array $labelattributes Any attributes to apply to the label, if present
|
|
* @return string html fragment
|
|
*/
|
|
public static function checkbox(
|
|
$name,
|
|
$value,
|
|
$checked = true,
|
|
$label = '',
|
|
?array $attributes = null,
|
|
?array $labelattributes = null,
|
|
) {
|
|
$attributes = (array) $attributes;
|
|
$output = '';
|
|
|
|
if ($label !== '' && !is_null($label)) {
|
|
if (empty($attributes['id'])) {
|
|
$attributes['id'] = self::random_id('checkbox_');
|
|
}
|
|
}
|
|
$attributes['type'] = 'checkbox';
|
|
$attributes['value'] = $value;
|
|
$attributes['name'] = $name;
|
|
$attributes['checked'] = $checked ? 'checked' : null;
|
|
|
|
$output .= self::empty_tag('input', $attributes);
|
|
|
|
if ($label !== '' && !is_null($label)) {
|
|
$labelattributes = (array) $labelattributes;
|
|
$labelattributes['for'] = $attributes['id'];
|
|
$output .= self::tag('label', $label, $labelattributes);
|
|
}
|
|
|
|
return $output;
|
|
}
|
|
|
|
/**
|
|
* Generates a simple select yes/no form field
|
|
*
|
|
* @param string $name name of select element
|
|
* @param bool $selected
|
|
* @param null|array $attributes - html select element attributes
|
|
* @return string HTML fragment
|
|
*/
|
|
public static function select_yes_no($name, $selected = true, ?array $attributes = null) {
|
|
$options = ['1' => get_string('yes'), '0' => get_string('no')];
|
|
return self::select($options, $name, $selected, null, $attributes);
|
|
}
|
|
|
|
/**
|
|
* Generates a simple select form field
|
|
*
|
|
* Note this function does HTML escaping on the optgroup labels, but not on the choice labels.
|
|
*
|
|
* @param array $options associative array value=>label ex.:
|
|
* array(1=>'One, 2=>Two)
|
|
* it is also possible to specify optgroup as complex label array ex.:
|
|
* array(array('Odd'=>array(1=>'One', 3=>'Three)), array('Even'=>array(2=>'Two')))
|
|
* array(1=>'One', '--1uniquekey'=>array('More'=>array(2=>'Two', 3=>'Three')))
|
|
* @param string $name name of select element
|
|
* @param string|array $selected value or array of values depending on multiple attribute
|
|
* @param array|bool|null $nothing add nothing selected option, or false of not added
|
|
* @param null|array $attributes html select element attributes
|
|
* @param array $disabled An array of disabled options.
|
|
* @return string HTML fragment
|
|
*/
|
|
public static function select(
|
|
array $options,
|
|
$name,
|
|
$selected = '',
|
|
$nothing = ['' => 'choosedots'],
|
|
?array $attributes = null,
|
|
array $disabled = [],
|
|
): string {
|
|
$attributes = (array)$attributes;
|
|
if (is_array($nothing)) {
|
|
foreach ($nothing as $k => $v) {
|
|
if ($v === 'choose' || $v === 'choosedots') {
|
|
$nothing[$k] = get_string('choosedots');
|
|
}
|
|
}
|
|
$options = $nothing + $options; // Keep keys, do not override.
|
|
} else if (is_string($nothing) && $nothing !== '') {
|
|
// BC.
|
|
$options = ['' => $nothing] + $options;
|
|
}
|
|
|
|
// We may accept more values if multiple attribute specified.
|
|
$selected = (array)$selected;
|
|
foreach ($selected as $k => $v) {
|
|
$selected[$k] = (string)$v;
|
|
}
|
|
|
|
if (!isset($attributes['id'])) {
|
|
$id = 'menu' . $name;
|
|
// Name may contain [], which would make an invalid id. e.g. numeric question type editing form, assignment quickgrading.
|
|
$id = str_replace('[', '', $id);
|
|
$id = str_replace(']', '', $id);
|
|
$attributes['id'] = $id;
|
|
}
|
|
|
|
if (!isset($attributes['class'])) {
|
|
$class = 'menu' . $name;
|
|
// Name may contain [], which would make an invalid class. e.g. numeric question type editing form, assignment quickgrading.
|
|
$class = str_replace('[', '', $class);
|
|
$class = str_replace(']', '', $class);
|
|
$attributes['class'] = $class;
|
|
}
|
|
$attributes['class'] = 'select form-select ' . $attributes['class']; // Add 'select' selector always.
|
|
|
|
$attributes['name'] = $name;
|
|
|
|
if (!empty($attributes['disabled'])) {
|
|
$attributes['disabled'] = 'disabled';
|
|
} else {
|
|
unset($attributes['disabled']);
|
|
}
|
|
|
|
$output = '';
|
|
foreach ($options as $value => $label) {
|
|
if (is_array($label)) {
|
|
// Ignore key, it just has to be unique.
|
|
$output .= self::select_optgroup(key($label), current($label), $selected, $disabled);
|
|
} else {
|
|
$output .= self::select_option($label, $value, $selected, $disabled);
|
|
}
|
|
}
|
|
return self::tag('select', $output, $attributes);
|
|
}
|
|
|
|
/**
|
|
* Returns HTML to display a select box option.
|
|
*
|
|
* @param string $label The label to display as the option.
|
|
* @param string|int $value The value the option represents
|
|
* @param array $selected An array of selected options
|
|
* @param array $disabled An array of disabled options.
|
|
* @return string HTML fragment
|
|
*/
|
|
private static function select_option($label, $value, array $selected, array $disabled = []): string {
|
|
$attributes = [];
|
|
$value = (string)$value;
|
|
if (in_array($value, $selected, true)) {
|
|
$attributes['selected'] = 'selected';
|
|
}
|
|
if (in_array($value, $disabled, true)) {
|
|
$attributes['disabled'] = 'disabled';
|
|
}
|
|
$attributes['value'] = $value;
|
|
return self::tag('option', $label, $attributes);
|
|
}
|
|
|
|
/**
|
|
* Returns HTML to display a select box option group.
|
|
*
|
|
* @param string $groupname The label to use for the group
|
|
* @param array $options The options in the group
|
|
* @param array $selected An array of selected values.
|
|
* @param array $disabled An array of disabled options.
|
|
* @return string HTML fragment.
|
|
*/
|
|
private static function select_optgroup($groupname, $options, array $selected, array $disabled = []): string {
|
|
if (empty($options)) {
|
|
return '';
|
|
}
|
|
$attributes = ['label' => $groupname];
|
|
$output = '';
|
|
foreach ($options as $value => $label) {
|
|
$output .= self::select_option($label, $value, $selected, $disabled);
|
|
}
|
|
return self::tag('optgroup', $output, $attributes);
|
|
}
|
|
|
|
/**
|
|
* This is a shortcut for making an hour selector menu.
|
|
*
|
|
* @param string $type The type of selector (years, months, days, hours, minutes)
|
|
* @param string $name fieldname
|
|
* @param int $currenttime A default timestamp in GMT
|
|
* @param int $step minute spacing
|
|
* @param null|array $attributes - html select element attributes
|
|
* @param float|int|string $timezone the timezone to use to calculate the time
|
|
* {@link https://moodledev.io/docs/apis/subsystems/time#timezone}
|
|
* @return string HTML fragment
|
|
*/
|
|
public static function select_time($type, $name, $currenttime = 0, $step = 5, ?array $attributes = null, $timezone = 99) {
|
|
global $OUTPUT;
|
|
|
|
if (!$currenttime) {
|
|
$currenttime = time();
|
|
}
|
|
$calendartype = \core_calendar\type_factory::get_calendar_instance();
|
|
$currentdate = $calendartype->timestamp_to_date_array($currenttime, $timezone);
|
|
|
|
$userdatetype = $type;
|
|
$timeunits = [];
|
|
|
|
switch ($type) {
|
|
case 'years':
|
|
$timeunits = $calendartype->get_years();
|
|
$userdatetype = 'year';
|
|
break;
|
|
case 'months':
|
|
$timeunits = $calendartype->get_months();
|
|
$userdatetype = 'month';
|
|
$currentdate['month'] = (int)$currentdate['mon'];
|
|
break;
|
|
case 'days':
|
|
$timeunits = $calendartype->get_days();
|
|
$userdatetype = 'mday';
|
|
break;
|
|
case 'hours':
|
|
for ($i = 0; $i <= 23; $i++) {
|
|
$timeunits[$i] = sprintf("%02d", $i);
|
|
}
|
|
break;
|
|
case 'minutes':
|
|
if ($step != 1) {
|
|
$currentdate['minutes'] = ceil($currentdate['minutes'] / $step) * $step;
|
|
}
|
|
|
|
for ($i = 0; $i <= 59; $i += $step) {
|
|
$timeunits[$i] = sprintf("%02d", $i);
|
|
}
|
|
break;
|
|
default:
|
|
throw new coding_exception("Time type $type is not supported by html_writer::select_time().");
|
|
}
|
|
|
|
$attributes = (array) $attributes;
|
|
$data = (object) [
|
|
'name' => $name,
|
|
'id' => !empty($attributes['id']) ? $attributes['id'] : self::random_id('ts_'),
|
|
'label' => get_string(substr($type, 0, -1), 'form'),
|
|
'options' => array_map(function ($value) use ($timeunits, $currentdate, $userdatetype) {
|
|
return [
|
|
'name' => $timeunits[$value],
|
|
'value' => $value,
|
|
'selected' => $currentdate[$userdatetype] == $value,
|
|
];
|
|
}, array_keys($timeunits)),
|
|
];
|
|
|
|
unset($attributes['id']);
|
|
unset($attributes['name']);
|
|
$data->attributes = array_map(function ($name) use ($attributes) {
|
|
return [
|
|
'name' => $name,
|
|
'value' => $attributes[$name],
|
|
];
|
|
}, array_keys($attributes));
|
|
|
|
return $OUTPUT->render_from_template('core/select_time', $data);
|
|
}
|
|
|
|
/**
|
|
* Shortcut for quick making of lists
|
|
*
|
|
* Note: 'list' is a reserved keyword ;-)
|
|
*
|
|
* @param array $items
|
|
* @param null|array $attributes
|
|
* @param string $tag ul or ol
|
|
* @return string
|
|
*/
|
|
public static function alist(array $items, ?array $attributes = null, $tag = 'ul') {
|
|
$output = self::start_tag($tag, $attributes) . "\n";
|
|
foreach ($items as $item) {
|
|
$output .= self::tag('li', $item) . "\n";
|
|
}
|
|
$output .= self::end_tag($tag);
|
|
return $output;
|
|
}
|
|
|
|
/**
|
|
* Returns hidden input fields created from url parameters.
|
|
*
|
|
* @param moodle_url $url
|
|
* @param null|array $exclude list of excluded parameters
|
|
* @return string HTML fragment
|
|
*/
|
|
public static function input_hidden_params(moodle_url $url, ?array $exclude = null) {
|
|
$exclude = (array)$exclude;
|
|
$params = $url->params();
|
|
foreach ($exclude as $key) {
|
|
unset($params[$key]);
|
|
}
|
|
|
|
$output = '';
|
|
foreach ($params as $key => $value) {
|
|
$attributes = ['type' => 'hidden', 'name' => $key, 'value' => $value];
|
|
$output .= self::empty_tag('input', $attributes) . "\n";
|
|
}
|
|
return $output;
|
|
}
|
|
|
|
/**
|
|
* Generate a script tag containing the the specified code.
|
|
*
|
|
* @param string $jscode the JavaScript code
|
|
* @param moodle_url|string $url optional url of the external script, $code ignored if specified
|
|
* @return string HTML, the code wrapped in <script> tags.
|
|
*/
|
|
public static function script($jscode, $url = null) {
|
|
if ($jscode) {
|
|
return self::tag('script', "\n//<![CDATA[\n$jscode\n//]]>\n") . "\n";
|
|
} else if ($url) {
|
|
return self::tag('script', '', ['src' => $url]) . "\n";
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Renders HTML table
|
|
*
|
|
* This method may modify the passed instance by adding some default properties if they are not set yet.
|
|
* If this is not what you want, you should make a full clone of your data before passing them to this
|
|
* method. In most cases this is not an issue at all so we do not clone by default for performance
|
|
* and memory consumption reasons.
|
|
*
|
|
* @param html_table $table data to be rendered
|
|
* @return string HTML code
|
|
*/
|
|
public static function table(html_table $table) {
|
|
// Prepare table data and populate missing properties with reasonable defaults.
|
|
if (!empty($table->align)) {
|
|
foreach ($table->align as $key => $aa) {
|
|
if ($aa) {
|
|
$table->align[$key] = 'text-align:' . fix_align_rtl($aa) . ';'; // Fix for RTL languages.
|
|
} else {
|
|
$table->align[$key] = null;
|
|
}
|
|
}
|
|
}
|
|
if (!empty($table->size)) {
|
|
foreach ($table->size as $key => $ss) {
|
|
if ($ss) {
|
|
$table->size[$key] = 'width:' . $ss . ';';
|
|
} else {
|
|
$table->size[$key] = null;
|
|
}
|
|
}
|
|
}
|
|
if (!empty($table->wrap)) {
|
|
foreach ($table->wrap as $key => $ww) {
|
|
if ($ww) {
|
|
$table->wrap[$key] = 'white-space:nowrap;';
|
|
} else {
|
|
$table->wrap[$key] = '';
|
|
}
|
|
}
|
|
}
|
|
if (!empty($table->head)) {
|
|
foreach ($table->head as $key => $val) {
|
|
if (!isset($table->align[$key])) {
|
|
$table->align[$key] = null;
|
|
}
|
|
if (!isset($table->size[$key])) {
|
|
$table->size[$key] = null;
|
|
}
|
|
if (!isset($table->wrap[$key])) {
|
|
$table->wrap[$key] = null;
|
|
}
|
|
}
|
|
}
|
|
if (empty($table->attributes['class'])) {
|
|
$table->attributes['class'] = 'generaltable';
|
|
}
|
|
if (!empty($table->tablealign)) {
|
|
$table->attributes['class'] .= ' boxalign' . $table->tablealign;
|
|
}
|
|
|
|
// Explicitly assigned properties override those defined via $table->attributes.
|
|
$table->attributes['class'] = trim($table->attributes['class']);
|
|
$attributes = array_merge($table->attributes, [
|
|
'id' => $table->id,
|
|
'width' => $table->width,
|
|
'summary' => $table->summary,
|
|
'cellpadding' => $table->cellpadding,
|
|
'cellspacing' => $table->cellspacing,
|
|
]);
|
|
$output = self::start_tag('table', $attributes) . "\n";
|
|
|
|
$countcols = 0;
|
|
|
|
// Output a caption if present.
|
|
if (!empty($table->caption)) {
|
|
$captionattributes = [];
|
|
if ($table->captionhide) {
|
|
$captionattributes['class'] = 'accesshide';
|
|
}
|
|
$output .= self::tag(
|
|
'caption',
|
|
$table->caption,
|
|
$captionattributes
|
|
);
|
|
}
|
|
|
|
if (!empty($table->head)) {
|
|
$countcols = count($table->head);
|
|
|
|
$output .= self::start_tag('thead', []) . "\n";
|
|
$output .= self::start_tag('tr', []) . "\n";
|
|
$keys = array_keys($table->head);
|
|
$lastkey = end($keys);
|
|
|
|
foreach ($table->head as $key => $heading) {
|
|
// Convert plain string headings into html_table_cell objects.
|
|
if (!($heading instanceof html_table_cell)) {
|
|
$headingtext = $heading;
|
|
$heading = new html_table_cell();
|
|
$heading->text = $headingtext;
|
|
$heading->header = true;
|
|
}
|
|
|
|
if ($heading->header !== false) {
|
|
$heading->header = true;
|
|
}
|
|
|
|
$tagtype = 'td';
|
|
if ($heading->header && (string)$heading->text != '') {
|
|
$tagtype = 'th';
|
|
}
|
|
|
|
$heading->attributes['class'] .= ' header c' . $key;
|
|
if (isset($table->headspan[$key]) && $table->headspan[$key] > 1) {
|
|
$heading->colspan = $table->headspan[$key];
|
|
$countcols += $table->headspan[$key] - 1;
|
|
}
|
|
|
|
if ($key == $lastkey) {
|
|
$heading->attributes['class'] .= ' lastcol';
|
|
}
|
|
if (isset($table->colclasses[$key])) {
|
|
$heading->attributes['class'] .= ' ' . $table->colclasses[$key];
|
|
}
|
|
$heading->attributes['class'] = trim($heading->attributes['class']);
|
|
$attributes = array_merge($heading->attributes, [
|
|
'style' => $table->align[$key] . $table->size[$key] . $heading->style,
|
|
'colspan' => $heading->colspan,
|
|
]);
|
|
|
|
if ($tagtype == 'th') {
|
|
$attributes['scope'] = !empty($heading->scope) ? $heading->scope : 'col';
|
|
}
|
|
|
|
$output .= self::tag($tagtype, $heading->text, $attributes) . "\n";
|
|
}
|
|
$output .= self::end_tag('tr') . "\n";
|
|
$output .= self::end_tag('thead') . "\n";
|
|
|
|
if (empty($table->data)) {
|
|
// For valid XHTML strict every table must contain either a valid tr
|
|
// or a valid tbody... both of which must contain a valid td.
|
|
$output .= self::start_tag('tbody', ['class' => 'empty']);
|
|
$output .= self::tag('tr', self::tag('td', '', ['colspan' => count($table->head)]));
|
|
$output .= self::end_tag('tbody');
|
|
}
|
|
}
|
|
|
|
if (!empty($table->data)) {
|
|
$keys = array_keys($table->data);
|
|
$lastrowkey = end($keys);
|
|
$output .= self::start_tag('tbody', []);
|
|
|
|
foreach ($table->data as $key => $row) {
|
|
if (($row === 'hr') && ($countcols)) {
|
|
$output .= self::tag('td', self::tag('div', '', ['class' => 'tabledivider']), ['colspan' => $countcols]);
|
|
} else {
|
|
// Convert array rows to html_table_rows and cell strings to html_table_cell objects.
|
|
if (!($row instanceof html_table_row)) {
|
|
$newrow = new html_table_row();
|
|
|
|
foreach ($row as $cell) {
|
|
if (!($cell instanceof html_table_cell)) {
|
|
$cell = new html_table_cell($cell);
|
|
}
|
|
$newrow->cells[] = $cell;
|
|
}
|
|
$row = $newrow;
|
|
}
|
|
|
|
if (isset($table->rowclasses[$key])) {
|
|
$row->attributes['class'] .= ' ' . $table->rowclasses[$key];
|
|
}
|
|
|
|
if ($key == $lastrowkey) {
|
|
$row->attributes['class'] .= ' lastrow';
|
|
}
|
|
|
|
// Explicitly assigned properties should override those defined in the attributes.
|
|
$row->attributes['class'] = trim($row->attributes['class']);
|
|
$trattributes = array_merge($row->attributes, [
|
|
'id' => $row->id,
|
|
'style' => $row->style,
|
|
]);
|
|
$output .= self::start_tag('tr', $trattributes) . "\n";
|
|
$keys2 = array_keys($row->cells);
|
|
$lastkey = end($keys2);
|
|
|
|
$gotlastkey = false; // Flag for sanity checking.
|
|
foreach ($row->cells as $key => $cell) {
|
|
if ($gotlastkey) {
|
|
// This should never happen. Why do we have a cell after the last cell?
|
|
mtrace("A cell with key ($key) was found after the last key ($lastkey)");
|
|
}
|
|
|
|
if (!($cell instanceof html_table_cell)) {
|
|
$mycell = new html_table_cell();
|
|
$mycell->text = $cell;
|
|
$cell = $mycell;
|
|
}
|
|
|
|
if (($cell->header === true) && empty($cell->scope)) {
|
|
$cell->scope = 'row';
|
|
}
|
|
|
|
if (isset($table->colclasses[$key])) {
|
|
$cell->attributes['class'] .= ' ' . $table->colclasses[$key];
|
|
}
|
|
|
|
$cell->attributes['class'] .= ' cell c' . $key;
|
|
if ($key == $lastkey) {
|
|
$cell->attributes['class'] .= ' lastcol';
|
|
$gotlastkey = true;
|
|
}
|
|
$tdstyle = '';
|
|
$tdstyle .= isset($table->align[$key]) ? $table->align[$key] : '';
|
|
$tdstyle .= isset($table->size[$key]) ? $table->size[$key] : '';
|
|
$tdstyle .= isset($table->wrap[$key]) ? $table->wrap[$key] : '';
|
|
$cell->attributes['class'] = trim($cell->attributes['class']);
|
|
$tdattributes = array_merge($cell->attributes, [
|
|
'style' => $tdstyle . $cell->style,
|
|
'colspan' => $cell->colspan,
|
|
'rowspan' => $cell->rowspan,
|
|
'id' => $cell->id,
|
|
'abbr' => $cell->abbr,
|
|
'scope' => $cell->scope,
|
|
]);
|
|
$tagtype = 'td';
|
|
if ($cell->header === true) {
|
|
$tagtype = 'th';
|
|
}
|
|
$output .= self::tag($tagtype, $cell->text, $tdattributes) . "\n";
|
|
}
|
|
}
|
|
$output .= self::end_tag('tr') . "\n";
|
|
}
|
|
$output .= self::end_tag('tbody') . "\n";
|
|
}
|
|
$output .= self::end_tag('table') . "\n";
|
|
|
|
if ($table->responsive) {
|
|
return self::div($output, 'table-responsive');
|
|
}
|
|
|
|
return $output;
|
|
}
|
|
|
|
/**
|
|
* Renders form element label
|
|
*
|
|
* By default, the label is suffixed with a label separator defined in the
|
|
* current language pack (colon by default in the English lang pack).
|
|
* Adding the colon can be explicitly disabled if needed. Label separators
|
|
* are put outside the label tag itself so they are not read by
|
|
* screenreaders (accessibility).
|
|
*
|
|
* Parameter $for explicitly associates the label with a form control. When
|
|
* set, the value of this attribute must be the same as the value of
|
|
* the id attribute of the form control in the same document. When null,
|
|
* the label being defined is associated with the control inside the label
|
|
* element.
|
|
*
|
|
* @param string $text content of the label tag
|
|
* @param string|null $for id of the element this label is associated with, null for no association
|
|
* @param bool $colonize add label separator (colon) to the label text, if it is not there yet
|
|
* @param array $attributes to be inserted in the tab, for example array('accesskey' => 'a')
|
|
* @return string HTML of the label element
|
|
*/
|
|
public static function label($text, $for, $colonize = true, array $attributes = []) {
|
|
if (!is_null($for)) {
|
|
$attributes = array_merge($attributes, ['for' => $for]);
|
|
}
|
|
$text = trim($text ?? '');
|
|
$label = self::tag('label', $text, $attributes);
|
|
|
|
// TODO MDL-12192 $colonize disabled for now yet
|
|
// if (!empty($text) and $colonize) {
|
|
// the $text may end with the colon already, though it is bad string definition style
|
|
// $colon = get_string('labelsep', 'langconfig');
|
|
// if (!empty($colon)) {
|
|
// $trimmed = trim($colon);
|
|
// if ((substr($text, -strlen($trimmed)) == $trimmed) or (substr($text, -1) == ':')) {
|
|
// debugging('The label text should not end with colon or other label separator,
|
|
// please fix the string definition.', DEBUG_DEVELOPER);
|
|
// } else {
|
|
// $label .= $colon;
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
return $label;
|
|
}
|
|
|
|
/**
|
|
* Combines a class parameter with other attributes. Aids in code reduction
|
|
* because the class parameter is very frequently used.
|
|
*
|
|
* If the class attribute is specified both in the attributes and in the
|
|
* class parameter, the two values are combined with a space between.
|
|
*
|
|
* @param string $class Optional CSS class (or classes as space-separated list)
|
|
* @param null|array $attributes Optional other attributes as array
|
|
* @return array Attributes (or null if still none)
|
|
*/
|
|
private static function add_class($class = '', ?array $attributes = null) {
|
|
if ($class !== '') {
|
|
$classattribute = ['class' => $class];
|
|
if ($attributes) {
|
|
if (array_key_exists('class', $attributes)) {
|
|
$attributes['class'] = trim($attributes['class'] . ' ' . $class);
|
|
} else {
|
|
$attributes = $classattribute + $attributes;
|
|
}
|
|
} else {
|
|
$attributes = $classattribute;
|
|
}
|
|
}
|
|
return $attributes;
|
|
}
|
|
|
|
/**
|
|
* Creates a <div> tag. (Shortcut function.)
|
|
*
|
|
* @param string $content HTML content of tag
|
|
* @param string $class Optional CSS class (or classes as space-separated list)
|
|
* @param null|array $attributes Optional other attributes as array
|
|
* @return string HTML code for div
|
|
*/
|
|
public static function div($content, $class = '', ?array $attributes = null) {
|
|
return self::tag('div', $content, self::add_class($class, $attributes));
|
|
}
|
|
|
|
/**
|
|
* Starts a <div> tag. (Shortcut function.)
|
|
*
|
|
* @param string $class Optional CSS class (or classes as space-separated list)
|
|
* @param null|array $attributes Optional other attributes as array
|
|
* @return string HTML code for open div tag
|
|
*/
|
|
public static function start_div($class = '', ?array $attributes = null) {
|
|
return self::start_tag('div', self::add_class($class, $attributes));
|
|
}
|
|
|
|
/**
|
|
* Ends a <div> tag. (Shortcut function.)
|
|
*
|
|
* @return string HTML code for close div tag
|
|
*/
|
|
public static function end_div() {
|
|
return self::end_tag('div');
|
|
}
|
|
|
|
/**
|
|
* Creates a <span> tag. (Shortcut function.)
|
|
*
|
|
* @param string $content HTML content of tag
|
|
* @param string $class Optional CSS class (or classes as space-separated list)
|
|
* @param null|array $attributes Optional other attributes as array
|
|
* @return string HTML code for span
|
|
*/
|
|
public static function span($content, $class = '', ?array $attributes = null) {
|
|
return self::tag('span', $content, self::add_class($class, $attributes));
|
|
}
|
|
|
|
/**
|
|
* Starts a <span> tag. (Shortcut function.)
|
|
*
|
|
* @param string $class Optional CSS class (or classes as space-separated list)
|
|
* @param null|array $attributes Optional other attributes as array
|
|
* @return string HTML code for open span tag
|
|
*/
|
|
public static function start_span($class = '', ?array $attributes = null) {
|
|
return self::start_tag('span', self::add_class($class, $attributes));
|
|
}
|
|
|
|
/**
|
|
* Ends a <span> tag. (Shortcut function.)
|
|
*
|
|
* @return string HTML code for close span tag
|
|
*/
|
|
public static function end_span() {
|
|
return self::end_tag('span');
|
|
}
|
|
}
|
|
|
|
// Alias this class to the old name.
|
|
// This file will be autoloaded by the legacyclasses autoload system.
|
|
// In future all uses of this class will be corrected and the legacy references will be removed.
|
|
class_alias(html_writer::class, \html_writer::class);
|