Search moodle.org's
Developer Documentation
Developer Documentation
- Bug fixes for general core bugs in 4.2.x will end 22 April 2024 (12 months).
- Bug fixes for security issues in 4.2.x will end 7 October 2024 (18 months).
- PHP version: minimum PHP 8.0.0 Note: minimum PHP version has increased since Moodle 4.1. PHP 8.1.x is supported too.
/lib/ -> outputlib.php (source)
Differences Between: [Versions 310 and 402] [Versions 311 and 402] [Versions 39 and 402] [Versions 400 and 402] [Versions 401 and 402] [Versions 402 and 403]
1 <?php 2 // This file is part of Moodle - http://moodle.org/ 3 // 4 // Moodle is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // Moodle is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU General Public License for more details. 13 // 14 // You should have received a copy of the GNU General Public License 15 // along with Moodle. If not, see <http://www.gnu.org/licenses/>. 16 17 /** 18 * Functions for generating the HTML that Moodle should output. 19 * 20 * Please see http://docs.moodle.org/en/Developement:How_Moodle_outputs_HTML 21 * for an overview. 22 * 23 * @copyright 2009 Tim Hunt 24 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later 25 * @package core 26 * @category output 27 */ 28 29 defined('MOODLE_INTERNAL') || die(); 30 31 require_once($CFG->libdir.'/outputcomponents.php'); 32 require_once($CFG->libdir.'/outputactions.php'); 33 require_once($CFG->libdir.'/outputfactories.php'); 34 require_once($CFG->libdir.'/outputrenderers.php'); 35 require_once($CFG->libdir.'/outputrequirementslib.php'); 36 37 /** 38 * Returns current theme revision number. 39 * 40 * @return int 41 */ 42 function theme_get_revision() { 43 global $CFG; 44 45 if (empty($CFG->themedesignermode)) { 46 if (empty($CFG->themerev)) { 47 // This only happens during install. It doesn't matter what themerev we use as long as it's positive. 48 return 1; 49 } else { 50 return $CFG->themerev; 51 } 52 53 } else { 54 return -1; 55 } 56 } 57 58 /** 59 * Returns current theme sub revision number. This is the revision for 60 * this theme exclusively, not the global theme revision. 61 * 62 * @param string $themename The non-frankenstyle name of the theme 63 * @return int 64 */ 65 function theme_get_sub_revision_for_theme($themename) { 66 global $CFG; 67 68 if (empty($CFG->themedesignermode)) { 69 $pluginname = "theme_{$themename}"; 70 $revision = during_initial_install() ? null : get_config($pluginname, 'themerev'); 71 72 if (empty($revision)) { 73 // This only happens during install. It doesn't matter what themerev we use as long as it's positive. 74 return 1; 75 } else { 76 return $revision; 77 } 78 } else { 79 return -1; 80 } 81 } 82 83 /** 84 * Calculates and returns the next theme revision number. 85 * 86 * @return int 87 */ 88 function theme_get_next_revision() { 89 global $CFG; 90 91 $next = time(); 92 if (isset($CFG->themerev) and $next <= $CFG->themerev and $CFG->themerev - $next < 60*60) { 93 // This resolves problems when reset is requested repeatedly within 1s, 94 // the < 1h condition prevents accidental switching to future dates 95 // because we might not recover from it. 96 $next = $CFG->themerev+1; 97 } 98 99 return $next; 100 } 101 102 /** 103 * Calculates and returns the next theme revision number. 104 * 105 * @param string $themename The non-frankenstyle name of the theme 106 * @return int 107 */ 108 function theme_get_next_sub_revision_for_theme($themename) { 109 global $CFG; 110 111 $next = time(); 112 $current = theme_get_sub_revision_for_theme($themename); 113 if ($next <= $current and $current - $next < 60 * 60) { 114 // This resolves problems when reset is requested repeatedly within 1s, 115 // the < 1h condition prevents accidental switching to future dates 116 // because we might not recover from it. 117 $next = $current + 1; 118 } 119 120 return $next; 121 } 122 123 /** 124 * Sets the current theme revision number. 125 * 126 * @param int $revision The new theme revision number 127 */ 128 function theme_set_revision($revision) { 129 set_config('themerev', $revision); 130 } 131 132 /** 133 * Sets the current theme revision number for a specific theme. 134 * This does not affect the global themerev value. 135 * 136 * @param string $themename The non-frankenstyle name of the theme 137 * @param int $revision The new theme revision number 138 */ 139 function theme_set_sub_revision_for_theme($themename, $revision) { 140 set_config('themerev', $revision, "theme_{$themename}"); 141 } 142 143 /** 144 * Get the path to a theme config.php file. 145 * 146 * @param string $themename The non-frankenstyle name of the theme to check 147 */ 148 function theme_get_config_file_path($themename) { 149 global $CFG; 150 151 if (file_exists("{$CFG->dirroot}/theme/{$themename}/config.php")) { 152 return "{$CFG->dirroot}/theme/{$themename}/config.php"; 153 } else if (!empty($CFG->themedir) and file_exists("{$CFG->themedir}/{$themename}/config.php")) { 154 return "{$CFG->themedir}/{$themename}/config.php"; 155 } else { 156 return null; 157 } 158 } 159 160 /** 161 * Get the path to the local cached CSS file. 162 * 163 * @param string $themename The non-frankenstyle theme name. 164 * @param int $globalrevision The global theme revision. 165 * @param int $themerevision The theme specific revision. 166 * @param string $direction Either 'ltr' or 'rtl' (case sensitive). 167 */ 168 function theme_get_css_filename($themename, $globalrevision, $themerevision, $direction) { 169 global $CFG; 170 171 $path = "{$CFG->localcachedir}/theme/{$globalrevision}/{$themename}/css"; 172 $filename = $direction == 'rtl' ? "all-rtl_{$themerevision}" : "all_{$themerevision}"; 173 return "{$path}/{$filename}.css"; 174 } 175 176 /** 177 * Generates and saves the CSS files for the given theme configs. 178 * 179 * @param theme_config[] $themeconfigs An array of theme_config instances. 180 * @param array $directions Must be a subset of ['rtl', 'ltr']. 181 * @param bool $cache Should the generated files be stored in local cache. 182 * @return array The built theme content in a multi-dimensional array of name => direction => content 183 */ 184 function theme_build_css_for_themes($themeconfigs = [], $directions = ['rtl', 'ltr'], 185 $cache = true, $mtraceprogress = false): array { 186 global $CFG; 187 188 if (empty($themeconfigs)) { 189 return []; 190 } 191 192 require_once("{$CFG->libdir}/csslib.php"); 193 194 $themescss = []; 195 $themerev = theme_get_revision(); 196 // Make sure the local cache directory exists. 197 make_localcache_directory('theme'); 198 199 foreach ($themeconfigs as $themeconfig) { 200 $themecss = []; 201 $oldrevision = theme_get_sub_revision_for_theme($themeconfig->name); 202 $newrevision = theme_get_next_sub_revision_for_theme($themeconfig->name); 203 204 // First generate all the new css. 205 foreach ($directions as $direction) { 206 if ($mtraceprogress) { 207 $timestart = microtime(true); 208 mtrace('Building theme CSS for ' . $themeconfig->name . ' [' . 209 $direction . '] ...', ''); 210 } 211 // Lock it on. Technically we should build all themes for SVG and no SVG - but ie9 is out of support. 212 $themeconfig->force_svg_use(true); 213 $themeconfig->set_rtl_mode(($direction === 'rtl')); 214 215 $themecss[$direction] = $themeconfig->get_css_content(); 216 if ($cache) { 217 $themeconfig->set_css_content_cache($themecss[$direction]); 218 $filename = theme_get_css_filename($themeconfig->name, $themerev, $newrevision, $direction); 219 css_store_css($themeconfig, $filename, $themecss[$direction]); 220 } 221 if ($mtraceprogress) { 222 mtrace(' done in ' . round(microtime(true) - $timestart, 2) . ' seconds.'); 223 } 224 } 225 $themescss[$themeconfig->name] = $themecss; 226 227 if ($cache) { 228 // Only update the theme revision after we've successfully created the 229 // new CSS cache. 230 theme_set_sub_revision_for_theme($themeconfig->name, $newrevision); 231 232 // Now purge old files. We must purge all old files in the local cache 233 // because we've incremented the theme sub revision. This will leave any 234 // files with the old revision inaccessbile so we might as well removed 235 // them from disk. 236 foreach (['ltr', 'rtl'] as $direction) { 237 $oldcss = theme_get_css_filename($themeconfig->name, $themerev, $oldrevision, $direction); 238 if (file_exists($oldcss)) { 239 unlink($oldcss); 240 } 241 } 242 } 243 } 244 245 return $themescss; 246 } 247 248 /** 249 * Invalidate all server and client side caches. 250 * 251 * This method deletes the physical directory that is used to cache the theme 252 * files used for serving. 253 * Because it deletes the main theme cache directory all themes are reset by 254 * this function. 255 */ 256 function theme_reset_all_caches() { 257 global $CFG, $PAGE; 258 require_once("{$CFG->libdir}/filelib.php"); 259 260 $next = theme_get_next_revision(); 261 theme_set_revision($next); 262 263 if (!empty($CFG->themedesignermode)) { 264 $cache = cache::make_from_params(cache_store::MODE_APPLICATION, 'core', 'themedesigner'); 265 $cache->purge(); 266 } 267 268 // Purge compiled post processed css. 269 cache::make('core', 'postprocessedcss')->purge(); 270 271 // Delete all old theme localcaches. 272 $themecachedirs = glob("{$CFG->localcachedir}/theme/*", GLOB_ONLYDIR); 273 foreach ($themecachedirs as $localcachedir) { 274 fulldelete($localcachedir); 275 } 276 277 if ($PAGE) { 278 $PAGE->reload_theme(); 279 } 280 } 281 282 /** 283 * Reset static caches. 284 * 285 * This method indicates that all running cron processes should exit at the 286 * next opportunity. 287 */ 288 function theme_reset_static_caches() { 289 \core\task\manager::clear_static_caches(); 290 } 291 292 /** 293 * Enable or disable theme designer mode. 294 * 295 * @param bool $state 296 */ 297 function theme_set_designer_mod($state) { 298 set_config('themedesignermode', (int)!empty($state)); 299 // Reset caches after switching mode so that any designer mode caches get purged too. 300 theme_reset_all_caches(); 301 } 302 303 /** 304 * Checks if the given device has a theme defined in config.php. 305 * 306 * @return bool 307 */ 308 function theme_is_device_locked($device) { 309 global $CFG; 310 $themeconfigname = core_useragent::get_device_type_cfg_var_name($device); 311 return isset($CFG->config_php_settings[$themeconfigname]); 312 } 313 314 /** 315 * Returns the theme named defined in config.php for the given device. 316 * 317 * @return string or null 318 */ 319 function theme_get_locked_theme_for_device($device) { 320 global $CFG; 321 322 if (!theme_is_device_locked($device)) { 323 return null; 324 } 325 326 $themeconfigname = core_useragent::get_device_type_cfg_var_name($device); 327 return $CFG->config_php_settings[$themeconfigname]; 328 } 329 330 /** 331 * This class represents the configuration variables of a Moodle theme. 332 * 333 * All the variables with access: public below (with a few exceptions that are marked) 334 * are the properties you can set in your themes config.php file. 335 * 336 * There are also some methods and protected variables that are part of the inner 337 * workings of Moodle's themes system. If you are just editing a themes config.php 338 * file, you can just ignore those, and the following information for developers. 339 * 340 * Normally, to create an instance of this class, you should use the 341 * {@link theme_config::load()} factory method to load a themes config.php file. 342 * However, normally you don't need to bother, because moodle_page (that is, $PAGE) 343 * will create one for you, accessible as $PAGE->theme. 344 * 345 * @copyright 2009 Tim Hunt 346 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later 347 * @since Moodle 2.0 348 * @package core 349 * @category output 350 */ 351 class theme_config { 352 353 /** 354 * @var string Default theme, used when requested theme not found. 355 */ 356 const DEFAULT_THEME = 'boost'; 357 358 /** The key under which the SCSS file is stored amongst the CSS files. */ 359 const SCSS_KEY = '__SCSS__'; 360 361 /** 362 * @var array You can base your theme on other themes by linking to the other theme as 363 * parents. This lets you use the CSS and layouts from the other themes 364 * (see {@link theme_config::$layouts}). 365 * That makes it easy to create a new theme that is similar to another one 366 * but with a few changes. In this themes CSS you only need to override 367 * those rules you want to change. 368 */ 369 public $parents; 370 371 /** 372 * @var array The names of all the stylesheets from this theme that you would 373 * like included, in order. Give the names of the files without .css. 374 */ 375 public $sheets = array(); 376 377 /** 378 * @var array The names of all the stylesheets from parents that should be excluded. 379 * true value may be used to specify all parents or all themes from one parent. 380 * If no value specified value from parent theme used. 381 */ 382 public $parents_exclude_sheets = null; 383 384 /** 385 * @var array List of plugin sheets to be excluded. 386 * If no value specified value from parent theme used. 387 */ 388 public $plugins_exclude_sheets = null; 389 390 /** 391 * @var array List of style sheets that are included in the text editor bodies. 392 * Sheets from parent themes are used automatically and can not be excluded. 393 */ 394 public $editor_sheets = array(); 395 396 /** 397 * @var bool Whether a fallback version of the stylesheet will be used 398 * whilst the final version is generated. 399 */ 400 public $usefallback = false; 401 402 /** 403 * @var array The names of all the javascript files this theme that you would 404 * like included from head, in order. Give the names of the files without .js. 405 */ 406 public $javascripts = array(); 407 408 /** 409 * @var array The names of all the javascript files this theme that you would 410 * like included from footer, in order. Give the names of the files without .js. 411 */ 412 public $javascripts_footer = array(); 413 414 /** 415 * @var array The names of all the javascript files from parents that should 416 * be excluded. true value may be used to specify all parents or all themes 417 * from one parent. 418 * If no value specified value from parent theme used. 419 */ 420 public $parents_exclude_javascripts = null; 421 422 /** 423 * @var array Which file to use for each page layout. 424 * 425 * This is an array of arrays. The keys of the outer array are the different layouts. 426 * Pages in Moodle are using several different layouts like 'normal', 'course', 'home', 427 * 'popup', 'form', .... The most reliable way to get a complete list is to look at 428 * {@link http://cvs.moodle.org/moodle/theme/base/config.php?view=markup the base theme config.php file}. 429 * That file also has a good example of how to set this setting. 430 * 431 * For each layout, the value in the outer array is an array that describes 432 * how you want that type of page to look. For example 433 * <pre> 434 * $THEME->layouts = array( 435 * // Most pages - if we encounter an unknown or a missing page type, this one is used. 436 * 'standard' => array( 437 * 'theme' = 'mytheme', 438 * 'file' => 'normal.php', 439 * 'regions' => array('side-pre', 'side-post'), 440 * 'defaultregion' => 'side-post' 441 * ), 442 * // The site home page. 443 * 'home' => array( 444 * 'theme' = 'mytheme', 445 * 'file' => 'home.php', 446 * 'regions' => array('side-pre', 'side-post'), 447 * 'defaultregion' => 'side-post' 448 * ), 449 * // ... 450 * ); 451 * </pre> 452 * 453 * 'theme' name of the theme where is the layout located 454 * 'file' is the layout file to use for this type of page. 455 * layout files are stored in layout subfolder 456 * 'regions' This lists the regions on the page where blocks may appear. For 457 * each region you list here, your layout file must include a call to 458 * <pre> 459 * echo $OUTPUT->blocks_for_region($regionname); 460 * </pre> 461 * or equivalent so that the blocks are actually visible. 462 * 463 * 'defaultregion' If the list of regions is non-empty, then you must pick 464 * one of the one of them as 'default'. This has two meanings. First, this is 465 * where new blocks are added. Second, if there are any blocks associated with 466 * the page, but in non-existent regions, they appear here. (Imaging, for example, 467 * that someone added blocks using a different theme that used different region 468 * names, and then switched to this theme.) 469 */ 470 public $layouts = array(); 471 472 /** 473 * @var string Name of the renderer factory class to use. Must implement the 474 * {@link renderer_factory} interface. 475 * 476 * This is an advanced feature. Moodle output is generated by 'renderers', 477 * you can customise the HTML that is output by writing custom renderers, 478 * and then you need to specify 'renderer factory' so that Moodle can find 479 * your renderers. 480 * 481 * There are some renderer factories supplied with Moodle. Please follow these 482 * links to see what they do. 483 * <ul> 484 * <li>{@link standard_renderer_factory} - the default.</li> 485 * <li>{@link theme_overridden_renderer_factory} - use this if you want to write 486 * your own custom renderers in a lib.php file in this theme (or the parent theme).</li> 487 * </ul> 488 */ 489 public $rendererfactory = 'standard_renderer_factory'; 490 491 /** 492 * @var string Function to do custom CSS post-processing. 493 * 494 * This is an advanced feature. If you want to do custom post-processing on the 495 * CSS before it is output (for example, to replace certain variable names 496 * with particular values) you can give the name of a function here. 497 */ 498 public $csspostprocess = null; 499 500 /** 501 * @var string Function to do custom CSS post-processing on a parsed CSS tree. 502 * 503 * This is an advanced feature. If you want to do custom post-processing on the 504 * CSS before it is output, you can provide the name of the function here. The 505 * function will receive a CSS tree document as first parameter, and the theme_config 506 * object as second parameter. A return value is not required, the tree can 507 * be edited in place. 508 */ 509 public $csstreepostprocessor = null; 510 511 /** 512 * @var string Accessibility: Right arrow-like character is 513 * used in the breadcrumb trail, course navigation menu 514 * (previous/next activity), calendar, and search forum block. 515 * If the theme does not set characters, appropriate defaults 516 * are set automatically. Please DO NOT 517 * use < > » - these are confusing for blind users. 518 */ 519 public $rarrow = null; 520 521 /** 522 * @var string Accessibility: Left arrow-like character is 523 * used in the breadcrumb trail, course navigation menu 524 * (previous/next activity), calendar, and search forum block. 525 * If the theme does not set characters, appropriate defaults 526 * are set automatically. Please DO NOT 527 * use < > » - these are confusing for blind users. 528 */ 529 public $larrow = null; 530 531 /** 532 * @var string Accessibility: Up arrow-like character is used in 533 * the book heirarchical navigation. 534 * If the theme does not set characters, appropriate defaults 535 * are set automatically. Please DO NOT 536 * use ^ - this is confusing for blind users. 537 */ 538 public $uarrow = null; 539 540 /** 541 * @var string Accessibility: Down arrow-like character. 542 * If the theme does not set characters, appropriate defaults 543 * are set automatically. 544 */ 545 public $darrow = null; 546 547 /** 548 * @var bool Some themes may want to disable ajax course editing. 549 */ 550 public $enablecourseajax = true; 551 552 /** 553 * @var string Determines served document types 554 * - 'html5' the only officially supported doctype in Moodle 555 * - 'xhtml5' may be used in development for validation (not intended for production servers!) 556 * - 'xhtml' XHTML 1.0 Strict for legacy themes only 557 */ 558 public $doctype = 'html5'; 559 560 /** 561 * @var string requiredblocks If set to a string, will list the block types that cannot be deleted. Defaults to 562 * navigation and settings. 563 */ 564 public $requiredblocks = false; 565 566 //==Following properties are not configurable from theme config.php== 567 568 /** 569 * @var string The name of this theme. Set automatically when this theme is 570 * loaded. This can not be set in theme config.php 571 */ 572 public $name; 573 574 /** 575 * @var string The folder where this themes files are stored. This is set 576 * automatically. This can not be set in theme config.php 577 */ 578 public $dir; 579 580 /** 581 * @var stdClass Theme settings stored in config_plugins table. 582 * This can not be set in theme config.php 583 */ 584 public $settings = null; 585 586 /** 587 * @var bool If set to true and the theme enables the dock then blocks will be able 588 * to be moved to the special dock 589 */ 590 public $enable_dock = false; 591 592 /** 593 * @var bool If set to true then this theme will not be shown in the theme selector unless 594 * theme designer mode is turned on. 595 */ 596 public $hidefromselector = false; 597 598 /** 599 * @var array list of YUI CSS modules to be included on each page. This may be used 600 * to remove cssreset and use cssnormalise module instead. 601 */ 602 public $yuicssmodules = array('cssreset', 'cssfonts', 'cssgrids', 'cssbase'); 603 604 /** 605 * An associative array of block manipulations that should be made if the user is using an rtl language. 606 * The key is the original block region, and the value is the block region to change to. 607 * This is used when displaying blocks for regions only. 608 * @var array 609 */ 610 public $blockrtlmanipulations = array(); 611 612 /** 613 * @var renderer_factory Instance of the renderer_factory implementation 614 * we are using. Implementation detail. 615 */ 616 protected $rf = null; 617 618 /** 619 * @var array List of parent config objects. 620 **/ 621 protected $parent_configs = array(); 622 623 /** 624 * Used to determine whether we can serve SVG images or not. 625 * @var bool 626 */ 627 private $usesvg = null; 628 629 /** 630 * Whether in RTL mode or not. 631 * @var bool 632 */ 633 protected $rtlmode = false; 634 635 /** 636 * The SCSS file to compile (without .scss), located in the scss/ folder of the theme. 637 * Or a Closure, which receives the theme_config as argument and must 638 * return the SCSS content. 639 * @var string|Closure 640 */ 641 public $scss = false; 642 643 /** 644 * Local cache of the SCSS property. 645 * @var false|array 646 */ 647 protected $scsscache = null; 648 649 /** 650 * The name of the function to call to get the SCSS code to inject. 651 * @var string 652 */ 653 public $extrascsscallback = null; 654 655 /** 656 * The name of the function to call to get SCSS to prepend. 657 * @var string 658 */ 659 public $prescsscallback = null; 660 661 /** 662 * Sets the render method that should be used for rendering custom block regions by scripts such as my/index.php 663 * Defaults to {@link core_renderer::blocks_for_region()} 664 * @var string 665 */ 666 public $blockrendermethod = null; 667 668 /** 669 * Remember the results of icon remapping for the current page. 670 * @var array 671 */ 672 public $remapiconcache = []; 673 674 /** 675 * The name of the function to call to get precompiled CSS. 676 * @var string 677 */ 678 public $precompiledcsscallback = null; 679 680 /** 681 * Whether the theme uses course index. 682 * @var bool 683 */ 684 public $usescourseindex = false; 685 686 /** 687 * Configuration for the page activity header 688 * @var array 689 */ 690 public $activityheaderconfig = []; 691 692 /** 693 * For backward compatibility with old themes. 694 * BLOCK_ADDBLOCK_POSITION_DEFAULT, BLOCK_ADDBLOCK_POSITION_FLATNAV. 695 * @var int 696 */ 697 public $addblockposition; 698 699 /** 700 * editor_scss file(s) provided by this theme. 701 * @var array 702 */ 703 public $editor_scss; 704 705 /** 706 * Name of the class extending \core\output\icon_system. 707 * @var string 708 */ 709 public $iconsystem; 710 711 /** 712 * Theme defines its own editing mode switch. 713 * @var bool 714 */ 715 public $haseditswitch = false; 716 717 /** 718 * Allows a theme to customise primary navigation by specifying the list of items to remove. 719 * @var array 720 */ 721 public $removedprimarynavitems = []; 722 723 /** 724 * Load the config.php file for a particular theme, and return an instance 725 * of this class. (That is, this is a factory method.) 726 * 727 * @param string $themename the name of the theme. 728 * @return theme_config an instance of this class. 729 */ 730 public static function load($themename) { 731 global $CFG; 732 733 // load theme settings from db 734 try { 735 $settings = get_config('theme_'.$themename); 736 } catch (dml_exception $e) { 737 // most probably moodle tables not created yet 738 $settings = new stdClass(); 739 } 740 741 if ($config = theme_config::find_theme_config($themename, $settings)) { 742 return new theme_config($config); 743 744 } else if ($themename == theme_config::DEFAULT_THEME) { 745 throw new coding_exception('Default theme '.theme_config::DEFAULT_THEME.' not available or broken!'); 746 747 } else if ($config = theme_config::find_theme_config($CFG->theme, $settings)) { 748 debugging('This page should be using theme ' . $themename . 749 ' which cannot be initialised. Falling back to the site theme ' . $CFG->theme, DEBUG_NORMAL); 750 return new theme_config($config); 751 752 } else { 753 // bad luck, the requested theme has some problems - admin see details in theme config 754 debugging('This page should be using theme ' . $themename . 755 ' which cannot be initialised. Nor can the site theme ' . $CFG->theme . 756 '. Falling back to ' . theme_config::DEFAULT_THEME, DEBUG_NORMAL); 757 return new theme_config(theme_config::find_theme_config(theme_config::DEFAULT_THEME, $settings)); 758 } 759 } 760 761 /** 762 * Theme diagnostic code. It is very problematic to send debug output 763 * to the actual CSS file, instead this functions is supposed to 764 * diagnose given theme and highlights all potential problems. 765 * This information should be available from the theme selection page 766 * or some other debug page for theme designers. 767 * 768 * @param string $themename 769 * @return array description of problems 770 */ 771 public static function diagnose($themename) { 772 //TODO: MDL-21108 773 return array(); 774 } 775 776 /** 777 * Private constructor, can be called only from the factory method. 778 * @param stdClass $config 779 */ 780 private function __construct($config) { 781 global $CFG; //needed for included lib.php files 782 783 $this->settings = $config->settings; 784 $this->name = $config->name; 785 $this->dir = $config->dir; 786 787 if ($this->name != self::DEFAULT_THEME) { 788 $baseconfig = self::find_theme_config(self::DEFAULT_THEME, $this->settings); 789 } else { 790 $baseconfig = $config; 791 } 792 793 // Ensure that each of the configurable properties defined below are also defined at the class level. 794 $configurable = [ 795 'parents', 'sheets', 'parents_exclude_sheets', 'plugins_exclude_sheets', 'usefallback', 796 'javascripts', 'javascripts_footer', 'parents_exclude_javascripts', 797 'layouts', 'enablecourseajax', 'requiredblocks', 798 'rendererfactory', 'csspostprocess', 'editor_sheets', 'editor_scss', 'rarrow', 'larrow', 'uarrow', 'darrow', 799 'hidefromselector', 'doctype', 'yuicssmodules', 'blockrtlmanipulations', 'blockrendermethod', 800 'scss', 'extrascsscallback', 'prescsscallback', 'csstreepostprocessor', 'addblockposition', 801 'iconsystem', 'precompiledcsscallback', 'haseditswitch', 'usescourseindex', 'activityheaderconfig', 802 'removedprimarynavitems', 803 ]; 804 805 foreach ($config as $key=>$value) { 806 if (in_array($key, $configurable)) { 807 $this->$key = $value; 808 } 809 } 810 811 // verify all parents and load configs and renderers 812 foreach ($this->parents as $parent) { 813 if (!$parent_config = theme_config::find_theme_config($parent, $this->settings)) { 814 // this is not good - better exclude faulty parents 815 continue; 816 } 817 $libfile = $parent_config->dir.'/lib.php'; 818 if (is_readable($libfile)) { 819 // theme may store various function here 820 include_once($libfile); 821 } 822 $renderersfile = $parent_config->dir.'/renderers.php'; 823 if (is_readable($renderersfile)) { 824 // may contain core and plugin renderers and renderer factory 825 include_once($renderersfile); 826 } 827 $this->parent_configs[$parent] = $parent_config; 828 } 829 $libfile = $this->dir.'/lib.php'; 830 if (is_readable($libfile)) { 831 // theme may store various function here 832 include_once($libfile); 833 } 834 $rendererfile = $this->dir.'/renderers.php'; 835 if (is_readable($rendererfile)) { 836 // may contain core and plugin renderers and renderer factory 837 include_once($rendererfile); 838 } else { 839 // check if renderers.php file is missnamed renderer.php 840 if (is_readable($this->dir.'/renderer.php')) { 841 debugging('Developer hint: '.$this->dir.'/renderer.php should be renamed to ' . $this->dir."/renderers.php. 842 See: http://docs.moodle.org/dev/Output_renderers#Theme_renderers.", DEBUG_DEVELOPER); 843 } 844 } 845 846 // cascade all layouts properly 847 foreach ($baseconfig->layouts as $layout=>$value) { 848 if (!isset($this->layouts[$layout])) { 849 foreach ($this->parent_configs as $parent_config) { 850 if (isset($parent_config->layouts[$layout])) { 851 $this->layouts[$layout] = $parent_config->layouts[$layout]; 852 continue 2; 853 } 854 } 855 $this->layouts[$layout] = $value; 856 } 857 } 858 859 //fix arrows if needed 860 $this->check_theme_arrows(); 861 } 862 863 /** 864 * Let the theme initialise the page object (usually $PAGE). 865 * 866 * This may be used for example to request jQuery in add-ons. 867 * 868 * @param moodle_page $page 869 */ 870 public function init_page(moodle_page $page) { 871 $themeinitfunction = 'theme_'.$this->name.'_page_init'; 872 if (function_exists($themeinitfunction)) { 873 $themeinitfunction($page); 874 } 875 } 876 877 /** 878 * Checks if arrows $THEME->rarrow, $THEME->larrow, $THEME->uarrow, $THEME->darrow have been set (theme/-/config.php). 879 * If not it applies sensible defaults. 880 * 881 * Accessibility: right and left arrow Unicode characters for breadcrumb, calendar, 882 * search forum block, etc. Important: these are 'silent' in a screen-reader 883 * (unlike > »), and must be accompanied by text. 884 */ 885 private function check_theme_arrows() { 886 if (!isset($this->rarrow) and !isset($this->larrow)) { 887 // Default, looks good in Win XP/IE 6, Win/Firefox 1.5, Win/Netscape 8... 888 // Also OK in Win 9x/2K/IE 5.x 889 $this->rarrow = '►'; 890 $this->larrow = '◄'; 891 $this->uarrow = '▲'; 892 $this->darrow = '▼'; 893 if (empty($_SERVER['HTTP_USER_AGENT'])) { 894 $uagent = ''; 895 } else { 896 $uagent = $_SERVER['HTTP_USER_AGENT']; 897 } 898 if (false !== strpos($uagent, 'Opera') 899 || false !== strpos($uagent, 'Mac')) { 900 // Looks good in Win XP/Mac/Opera 8/9, Mac/Firefox 2, Camino, Safari. 901 // Not broken in Mac/IE 5, Mac/Netscape 7 (?). 902 $this->rarrow = '▶︎'; 903 $this->larrow = '◀︎'; 904 } 905 elseif ((false !== strpos($uagent, 'Konqueror')) 906 || (false !== strpos($uagent, 'Android'))) { 907 // The fonts on Android don't include the characters required for this to work as expected. 908 // So we use the same ones Konqueror uses. 909 $this->rarrow = '→'; 910 $this->larrow = '←'; 911 $this->uarrow = '↑'; 912 $this->darrow = '↓'; 913 } 914 elseif (isset($_SERVER['HTTP_ACCEPT_CHARSET']) 915 && false === stripos($_SERVER['HTTP_ACCEPT_CHARSET'], 'utf-8')) { 916 // (Win/IE 5 doesn't set ACCEPT_CHARSET, but handles Unicode.) 917 // To be safe, non-Unicode browsers! 918 $this->rarrow = '>'; 919 $this->larrow = '<'; 920 $this->uarrow = '^'; 921 $this->darrow = 'v'; 922 } 923 924 // RTL support - in RTL languages, swap r and l arrows 925 if (right_to_left()) { 926 $t = $this->rarrow; 927 $this->rarrow = $this->larrow; 928 $this->larrow = $t; 929 } 930 } 931 } 932 933 /** 934 * Returns output renderer prefixes, these are used when looking 935 * for the overridden renderers in themes. 936 * 937 * @return array 938 */ 939 public function renderer_prefixes() { 940 global $CFG; // just in case the included files need it 941 942 $prefixes = array('theme_'.$this->name); 943 944 foreach ($this->parent_configs as $parent) { 945 $prefixes[] = 'theme_'.$parent->name; 946 } 947 948 return $prefixes; 949 } 950 951 /** 952 * Returns the stylesheet URL of this editor content 953 * 954 * @param bool $encoded false means use & and true use & in URLs 955 * @return moodle_url 956 */ 957 public function editor_css_url($encoded=true) { 958 global $CFG; 959 $rev = theme_get_revision(); 960 $type = 'editor'; 961 if (right_to_left()) { 962 $type .= '-rtl'; 963 } 964 965 if ($rev > -1) { 966 $themesubrevision = theme_get_sub_revision_for_theme($this->name); 967 968 // Provide the sub revision to allow us to invalidate cached theme CSS 969 // on a per theme basis, rather than globally. 970 if ($themesubrevision && $themesubrevision > 0) { 971 $rev .= "_{$themesubrevision}"; 972 } 973 974 $url = new moodle_url("/theme/styles.php"); 975 if (!empty($CFG->slasharguments)) { 976 $url->set_slashargument("/{$this->name}/{$rev}/{$type}", 'noparam', true); 977 } else { 978 $url->params([ 979 'theme' => $this->name, 980 'rev' => $rev, 981 'type' => $type, 982 ]); 983 } 984 } else { 985 $url = new moodle_url('/theme/styles_debug.php', [ 986 'theme' => $this->name, 987 'type' => $type, 988 ]); 989 } 990 return $url; 991 } 992 993 /** 994 * Returns the content of the CSS to be used in editor content 995 * 996 * @return array 997 */ 998 public function editor_css_files() { 999 $files = array(); 1000 1001 // First editor plugins. 1002 $plugins = core_component::get_plugin_list('editor'); 1003 foreach ($plugins as $plugin => $fulldir) { 1004 $sheetfile = "$fulldir/editor_styles.css"; 1005 if (is_readable($sheetfile)) { 1006 $files['plugin_'.$plugin] = $sheetfile; 1007 } 1008 1009 $subplugintypes = core_component::get_subplugins("editor_{$plugin}") ?? []; 1010 // Fetch sheets for any editor subplugins. 1011 foreach ($subplugintypes as $plugintype => $subplugins) { 1012 foreach ($subplugins as $subplugin) { 1013 $plugindir = core_component::get_plugin_directory($plugintype, $subplugin); 1014 $sheetfile = "{$plugindir}/editor_styles.css"; 1015 if (is_readable($sheetfile)) { 1016 $files["{$plugintype}_{$subplugin}"] = $sheetfile; 1017 } 1018 } 1019 } 1020 } 1021 1022 // Then parent themes - base first, the immediate parent last. 1023 foreach (array_reverse($this->parent_configs) as $parent_config) { 1024 if (empty($parent_config->editor_sheets)) { 1025 continue; 1026 } 1027 foreach ($parent_config->editor_sheets as $sheet) { 1028 $sheetfile = "$parent_config->dir/style/$sheet.css"; 1029 if (is_readable($sheetfile)) { 1030 $files['parent_'.$parent_config->name.'_'.$sheet] = $sheetfile; 1031 } 1032 } 1033 } 1034 // Finally this theme. 1035 if (!empty($this->editor_sheets)) { 1036 foreach ($this->editor_sheets as $sheet) { 1037 $sheetfile = "$this->dir/style/$sheet.css"; 1038 if (is_readable($sheetfile)) { 1039 $files['theme_'.$sheet] = $sheetfile; 1040 } 1041 } 1042 } 1043 1044 return $files; 1045 } 1046 1047 /** 1048 * Compiles and returns the content of the SCSS to be used in editor content 1049 * 1050 * @return string Compiled CSS from the editor SCSS 1051 */ 1052 public function editor_scss_to_css() { 1053 $css = ''; 1054 $dir = $this->dir; 1055 $filenames = []; 1056 1057 // Use editor_scss file(s) provided by this theme if set. 1058 if (!empty($this->editor_scss)) { 1059 $filenames = $this->editor_scss; 1060 } else { 1061 // If no editor_scss set, move up theme hierarchy until one is found (if at all). 1062 // This is so child themes only need to set editor_scss if an override is required. 1063 foreach (array_reverse($this->parent_configs) as $parentconfig) { 1064 if (!empty($parentconfig->editor_scss)) { 1065 $dir = $parentconfig->dir; 1066 $filenames = $parentconfig->editor_scss; 1067 1068 // Config found, stop looking. 1069 break; 1070 } 1071 } 1072 } 1073 1074 if (!empty($filenames)) { 1075 $compiler = new core_scss(); 1076 1077 foreach ($filenames as $filename) { 1078 $compiler->set_file("{$dir}/scss/{$filename}.scss"); 1079 1080 try { 1081 $css .= $compiler->to_css(); 1082 } catch (\Exception $e) { 1083 debugging('Error while compiling editor SCSS: ' . $e->getMessage(), DEBUG_DEVELOPER); 1084 } 1085 } 1086 } 1087 1088 return $css; 1089 } 1090 1091 /** 1092 * Get the stylesheet URL of this theme. 1093 * 1094 * @param moodle_page $page Not used... deprecated? 1095 * @return moodle_url[] 1096 */ 1097 public function css_urls(moodle_page $page) { 1098 global $CFG; 1099 1100 $rev = theme_get_revision(); 1101 1102 $urls = array(); 1103 1104 $svg = $this->use_svg_icons(); 1105 $separate = (core_useragent::is_ie() && !core_useragent::check_ie_version('10')); 1106 1107 if ($rev > -1) { 1108 $filename = right_to_left() ? 'all-rtl' : 'all'; 1109 $url = new moodle_url("/theme/styles.php"); 1110 $themesubrevision = theme_get_sub_revision_for_theme($this->name); 1111 1112 // Provide the sub revision to allow us to invalidate cached theme CSS 1113 // on a per theme basis, rather than globally. 1114 if ($themesubrevision && $themesubrevision > 0) { 1115 $rev .= "_{$themesubrevision}"; 1116 } 1117 1118 if (!empty($CFG->slasharguments)) { 1119 $slashargs = ''; 1120 if (!$svg) { 1121 // We add a simple /_s to the start of the path. 1122 // The underscore is used to ensure that it isn't a valid theme name. 1123 $slashargs .= '/_s'.$slashargs; 1124 } 1125 $slashargs .= '/'.$this->name.'/'.$rev.'/'.$filename; 1126 if ($separate) { 1127 $slashargs .= '/chunk0'; 1128 } 1129 $url->set_slashargument($slashargs, 'noparam', true); 1130 } else { 1131 $params = array('theme' => $this->name, 'rev' => $rev, 'type' => $filename); 1132 if (!$svg) { 1133 // We add an SVG param so that we know not to serve SVG images. 1134 // We do this because all modern browsers support SVG and this param will one day be removed. 1135 $params['svg'] = '0'; 1136 } 1137 if ($separate) { 1138 $params['chunk'] = '0'; 1139 } 1140 $url->params($params); 1141 } 1142 $urls[] = $url; 1143 1144 } else { 1145 $baseurl = new moodle_url('/theme/styles_debug.php'); 1146 1147 $css = $this->get_css_files(true); 1148 if (!$svg) { 1149 // We add an SVG param so that we know not to serve SVG images. 1150 // We do this because all modern browsers support SVG and this param will one day be removed. 1151 $baseurl->param('svg', '0'); 1152 } 1153 if (right_to_left()) { 1154 $baseurl->param('rtl', 1); 1155 } 1156 if ($separate) { 1157 // We might need to chunk long files. 1158 $baseurl->param('chunk', '0'); 1159 } 1160 if (core_useragent::is_ie()) { 1161 // Lalala, IE does not allow more than 31 linked CSS files from main document. 1162 $urls[] = new moodle_url($baseurl, array('theme'=>$this->name, 'type'=>'ie', 'subtype'=>'plugins')); 1163 foreach ($css['parents'] as $parent=>$sheets) { 1164 // We need to serve parents individually otherwise we may easily exceed the style limit IE imposes (4096). 1165 $urls[] = new moodle_url($baseurl, array('theme'=>$this->name,'type'=>'ie', 'subtype'=>'parents', 'sheet'=>$parent)); 1166 } 1167 if ($this->get_scss_property()) { 1168 // No need to define the type as IE here. 1169 $urls[] = new moodle_url($baseurl, array('theme' => $this->name, 'type' => 'scss')); 1170 } 1171 $urls[] = new moodle_url($baseurl, array('theme'=>$this->name, 'type'=>'ie', 'subtype'=>'theme')); 1172 1173 } else { 1174 foreach ($css['plugins'] as $plugin=>$unused) { 1175 $urls[] = new moodle_url($baseurl, array('theme'=>$this->name,'type'=>'plugin', 'subtype'=>$plugin)); 1176 } 1177 foreach ($css['parents'] as $parent=>$sheets) { 1178 foreach ($sheets as $sheet=>$unused2) { 1179 $urls[] = new moodle_url($baseurl, array('theme'=>$this->name,'type'=>'parent', 'subtype'=>$parent, 'sheet'=>$sheet)); 1180 } 1181 } 1182 foreach ($css['theme'] as $sheet => $filename) { 1183 if ($sheet === self::SCSS_KEY) { 1184 // This is the theme SCSS file. 1185 $urls[] = new moodle_url($baseurl, array('theme' => $this->name, 'type' => 'scss')); 1186 } else { 1187 // Sheet first in order to make long urls easier to read. 1188 $urls[] = new moodle_url($baseurl, array('sheet'=>$sheet, 'theme'=>$this->name, 'type'=>'theme')); 1189 } 1190 } 1191 } 1192 } 1193 1194 // Allow themes to change the css url to something like theme/mytheme/mycss.php. 1195 component_callback('theme_' . $this->name, 'alter_css_urls', [&$urls]); 1196 return $urls; 1197 } 1198 1199 /** 1200 * Get the whole css stylesheet for production mode. 1201 * 1202 * NOTE: this method is not expected to be used from any addons. 1203 * 1204 * @return string CSS markup compressed 1205 */ 1206 public function get_css_content() { 1207 1208 $csscontent = ''; 1209 foreach ($this->get_css_files(false) as $type => $value) { 1210 foreach ($value as $identifier => $val) { 1211 if (is_array($val)) { 1212 foreach ($val as $v) { 1213 $csscontent .= file_get_contents($v) . "\n"; 1214 } 1215 } else { 1216 if ($type === 'theme' && $identifier === self::SCSS_KEY) { 1217 // We need the content from SCSS because this is the SCSS file from the theme. 1218 if ($compiled = $this->get_css_content_from_scss(false)) { 1219 $csscontent .= $compiled; 1220 } else { 1221 // The compiler failed so default back to any precompiled css that might 1222 // exist. 1223 $csscontent .= $this->get_precompiled_css_content(); 1224 } 1225 } else { 1226 $csscontent .= file_get_contents($val) . "\n"; 1227 } 1228 } 1229 } 1230 } 1231 $csscontent = $this->post_process($csscontent); 1232 $csscontent = core_minify::css($csscontent); 1233 1234 return $csscontent; 1235 } 1236 /** 1237 * Set post processed CSS content cache. 1238 * 1239 * @param string $csscontent The post processed CSS content. 1240 * @return bool True if the content was successfully cached. 1241 */ 1242 public function set_css_content_cache($csscontent) { 1243 1244 $cache = cache::make('core', 'postprocessedcss'); 1245 $key = $this->get_css_cache_key(); 1246 1247 return $cache->set($key, $csscontent); 1248 } 1249 1250 /** 1251 * Return whether the post processed CSS content has been cached. 1252 * 1253 * @return bool Whether the post-processed CSS is available in the cache. 1254 */ 1255 public function has_css_cached_content() { 1256 1257 $key = $this->get_css_cache_key(); 1258 $cache = cache::make('core', 'postprocessedcss'); 1259 1260 return $cache->has($key); 1261 } 1262 1263 /** 1264 * Return cached post processed CSS content. 1265 * 1266 * @return bool|string The cached css content or false if not found. 1267 */ 1268 public function get_css_cached_content() { 1269 1270 $key = $this->get_css_cache_key(); 1271 $cache = cache::make('core', 'postprocessedcss'); 1272 1273 return $cache->get($key); 1274 } 1275 1276 /** 1277 * Generate the css content cache key. 1278 * 1279 * @return string The post processed css cache key. 1280 */ 1281 public function get_css_cache_key() { 1282 $nosvg = (!$this->use_svg_icons()) ? 'nosvg_' : ''; 1283 $rtlmode = ($this->rtlmode == true) ? 'rtl' : 'ltr'; 1284 1285 return $nosvg . $this->name . '_' . $rtlmode; 1286 } 1287 1288 /** 1289 * Get the theme designer css markup, 1290 * the parameters are coming from css_urls(). 1291 * 1292 * NOTE: this method is not expected to be used from any addons. 1293 * 1294 * @param string $type 1295 * @param string $subtype 1296 * @param string $sheet 1297 * @return string CSS markup 1298 */ 1299 public function get_css_content_debug($type, $subtype, $sheet) { 1300 if ($type === 'scss') { 1301 // The SCSS file of the theme is requested. 1302 $csscontent = $this->get_css_content_from_scss(true); 1303 if ($csscontent !== false) { 1304 return $this->post_process($csscontent); 1305 } 1306 return ''; 1307 } 1308 1309 $cssfiles = array(); 1310 $css = $this->get_css_files(true); 1311 1312 if ($type === 'ie') { 1313 // IE is a sloppy browser with weird limits, sorry. 1314 if ($subtype === 'plugins') { 1315 $cssfiles = $css['plugins']; 1316 1317 } else if ($subtype === 'parents') { 1318 if (empty($sheet)) { 1319 // Do not bother with the empty parent here. 1320 } else { 1321 // Build up the CSS for that parent so we can serve it as one file. 1322 foreach ($css[$subtype][$sheet] as $parent => $css) { 1323 $cssfiles[] = $css; 1324 } 1325 } 1326 } else if ($subtype === 'theme') { 1327 $cssfiles = $css['theme']; 1328 foreach ($cssfiles as $key => $value) { 1329 if (in_array($key, [self::SCSS_KEY])) { 1330 // Remove the SCSS file from the theme CSS files. 1331 // The SCSS files use the type 'scss', not 'ie'. 1332 unset($cssfiles[$key]); 1333 } 1334 } 1335 } 1336 1337 } else if ($type === 'plugin') { 1338 if (isset($css['plugins'][$subtype])) { 1339 $cssfiles[] = $css['plugins'][$subtype]; 1340 } 1341 1342 } else if ($type === 'parent') { 1343 if (isset($css['parents'][$subtype][$sheet])) { 1344 $cssfiles[] = $css['parents'][$subtype][$sheet]; 1345 } 1346 1347 } else if ($type === 'theme') { 1348 if (isset($css['theme'][$sheet])) { 1349 $cssfiles[] = $css['theme'][$sheet]; 1350 } 1351 } 1352 1353 $csscontent = ''; 1354 foreach ($cssfiles as $file) { 1355 $contents = file_get_contents($file); 1356 $contents = $this->post_process($contents); 1357 $comment = "/** Path: $type $subtype $sheet.' **/\n"; 1358 $stats = ''; 1359 $csscontent .= $comment.$stats.$contents."\n\n"; 1360 } 1361 1362 return $csscontent; 1363 } 1364 1365 /** 1366 * Get the whole css stylesheet for editor iframe. 1367 * 1368 * NOTE: this method is not expected to be used from any addons. 1369 * 1370 * @return string CSS markup 1371 */ 1372 public function get_css_content_editor() { 1373 $css = ''; 1374 $cssfiles = $this->editor_css_files(); 1375 1376 // If editor has static CSS, include it. 1377 foreach ($cssfiles as $file) { 1378 $css .= file_get_contents($file)."\n"; 1379 } 1380 1381 // If editor has SCSS, compile and include it. 1382 if (($convertedscss = $this->editor_scss_to_css())) { 1383 $css .= $convertedscss; 1384 } 1385 1386 $output = $this->post_process($css); 1387 1388 return $output; 1389 } 1390 1391 /** 1392 * Returns an array of organised CSS files required for this output. 1393 * 1394 * @param bool $themedesigner 1395 * @return array nested array of file paths 1396 */ 1397 protected function get_css_files($themedesigner) { 1398 global $CFG; 1399 1400 $cache = null; 1401 $cachekey = 'cssfiles'; 1402 if ($themedesigner) { 1403 require_once($CFG->dirroot.'/lib/csslib.php'); 1404 // We need some kind of caching here because otherwise the page navigation becomes 1405 // way too slow in theme designer mode. Feel free to create full cache definition later... 1406 $cache = cache::make_from_params(cache_store::MODE_APPLICATION, 'core', 'themedesigner', array('theme' => $this->name)); 1407 if ($files = $cache->get($cachekey)) { 1408 if ($files['created'] > time() - THEME_DESIGNER_CACHE_LIFETIME) { 1409 unset($files['created']); 1410 return $files; 1411 } 1412 } 1413 } 1414 1415 $cssfiles = array('plugins'=>array(), 'parents'=>array(), 'theme'=>array()); 1416 1417 // Get all plugin sheets. 1418 $excludes = $this->resolve_excludes('plugins_exclude_sheets'); 1419 if ($excludes !== true) { 1420 foreach (core_component::get_plugin_types() as $type=>$unused) { 1421 if ($type === 'theme' || (!empty($excludes[$type]) and $excludes[$type] === true)) { 1422 continue; 1423 } 1424 $plugins = core_component::get_plugin_list($type); 1425 foreach ($plugins as $plugin=>$fulldir) { 1426 if (!empty($excludes[$type]) and is_array($excludes[$type]) 1427 and in_array($plugin, $excludes[$type])) { 1428 continue; 1429 } 1430 1431 // Get the CSS from the plugin. 1432 $sheetfile = "$fulldir/styles.css"; 1433 if (is_readable($sheetfile)) { 1434 $cssfiles['plugins'][$type.'_'.$plugin] = $sheetfile; 1435 } 1436 1437 // Create a list of candidate sheets from parents (direct parent last) and current theme. 1438 $candidates = array(); 1439 foreach (array_reverse($this->parent_configs) as $parent_config) { 1440 $candidates[] = $parent_config->name; 1441 } 1442 $candidates[] = $this->name; 1443 1444 // Add the sheets found. 1445 foreach ($candidates as $candidate) { 1446 $sheetthemefile = "$fulldir/styles_{$candidate}.css"; 1447 if (is_readable($sheetthemefile)) { 1448 $cssfiles['plugins'][$type.'_'.$plugin.'_'.$candidate] = $sheetthemefile; 1449 } 1450 } 1451 } 1452 } 1453 } 1454 1455 // Find out wanted parent sheets. 1456 $excludes = $this->resolve_excludes('parents_exclude_sheets'); 1457 if ($excludes !== true) { 1458 foreach (array_reverse($this->parent_configs) as $parent_config) { // Base first, the immediate parent last. 1459 $parent = $parent_config->name; 1460 if (empty($parent_config->sheets) || (!empty($excludes[$parent]) and $excludes[$parent] === true)) { 1461 continue; 1462 } 1463 foreach ($parent_config->sheets as $sheet) { 1464 if (!empty($excludes[$parent]) && is_array($excludes[$parent]) 1465 && in_array($sheet, $excludes[$parent])) { 1466 continue; 1467 } 1468 1469 // We never refer to the parent LESS files. 1470 $sheetfile = "$parent_config->dir/style/$sheet.css"; 1471 if (is_readable($sheetfile)) { 1472 $cssfiles['parents'][$parent][$sheet] = $sheetfile; 1473 } 1474 } 1475 } 1476 } 1477 1478 1479 // Current theme sheets. 1480 // We first add the SCSS file because we want the CSS ones to 1481 // be included after the SCSS code. 1482 if ($this->get_scss_property()) { 1483 $cssfiles['theme'][self::SCSS_KEY] = true; 1484 } 1485 if (is_array($this->sheets)) { 1486 foreach ($this->sheets as $sheet) { 1487 $sheetfile = "$this->dir/style/$sheet.css"; 1488 if (is_readable($sheetfile) && !isset($cssfiles['theme'][$sheet])) { 1489 $cssfiles['theme'][$sheet] = $sheetfile; 1490 } 1491 } 1492 } 1493 1494 if ($cache) { 1495 $files = $cssfiles; 1496 $files['created'] = time(); 1497 $cache->set($cachekey, $files); 1498 } 1499 return $cssfiles; 1500 } 1501 1502 /** 1503 * Return the CSS content generated from the SCSS file. 1504 * 1505 * @param bool $themedesigner True if theme designer is enabled. 1506 * @return bool|string Return false when the compilation failed. Else the compiled string. 1507 */ 1508 protected function get_css_content_from_scss($themedesigner) { 1509 global $CFG; 1510 1511 list($paths, $scss) = $this->get_scss_property(); 1512 if (!$scss) { 1513 throw new coding_exception('The theme did not define a SCSS file, or it is not readable.'); 1514 } 1515 1516 // We might need more memory/time to do this, so let's play safe. 1517 raise_memory_limit(MEMORY_EXTRA); 1518 core_php_time_limit::raise(300); 1519 1520 // TODO: MDL-62757 When changing anything in this method please do not forget to check 1521 // if the validate() method in class admin_setting_configthemepreset needs updating too. 1522 1523 $cachedir = make_localcache_directory('scsscache-' . $this->name, false); 1524 $cacheoptions = []; 1525 if ($themedesigner) { 1526 $cacheoptions = array( 1527 'cacheDir' => $cachedir, 1528 'prefix' => 'scssphp_', 1529 'forceRefresh' => false, 1530 ); 1531 } else { 1532 if (file_exists($cachedir)) { 1533 remove_dir($cachedir); 1534 } 1535 } 1536 1537 // Set-up the compiler. 1538 $compiler = new core_scss($cacheoptions); 1539 1540 if ($this->supports_source_maps($themedesigner)) { 1541 // Enable source maps. 1542 $compiler->setSourceMapOptions([ 1543 'sourceMapBasepath' => str_replace('\\', '/', $CFG->dirroot), 1544 'sourceMapRootpath' => $CFG->wwwroot . '/' 1545 ]); 1546 $compiler->setSourceMap($compiler::SOURCE_MAP_INLINE); 1547 } 1548 1549 $compiler->prepend_raw_scss($this->get_pre_scss_code()); 1550 if (is_string($scss)) { 1551 $compiler->set_file($scss); 1552 } else { 1553 $compiler->append_raw_scss($scss($this)); 1554 $compiler->setImportPaths($paths); 1555 } 1556 $compiler->append_raw_scss($this->get_extra_scss_code()); 1557 1558 try { 1559 // Compile! 1560 $compiled = $compiler->to_css(); 1561 1562 } catch (\Exception $e) { 1563 $compiled = false; 1564 debugging('Error while compiling SCSS: ' . $e->getMessage(), DEBUG_DEVELOPER); 1565 } 1566 1567 // Try to save memory. 1568 $compiler = null; 1569 unset($compiler); 1570 1571 return $compiled; 1572 } 1573 1574 /** 1575 * Return the precompiled CSS if the precompiledcsscallback exists. 1576 * 1577 * @return string Return compiled css. 1578 */ 1579 public function get_precompiled_css_content() { 1580 $configs = array_reverse($this->parent_configs) + [$this]; 1581 $css = ''; 1582 1583 foreach ($configs as $config) { 1584 if (isset($config->precompiledcsscallback)) { 1585 $function = $config->precompiledcsscallback; 1586 if (function_exists($function)) { 1587 $css .= $function($this); 1588 } 1589 } 1590 } 1591 return $css; 1592 } 1593 1594 /** 1595 * Get the icon system to use. 1596 * 1597 * @return string 1598 */ 1599 public function get_icon_system() { 1600 1601 // Getting all the candidate functions. 1602 $system = false; 1603 if (isset($this->iconsystem) && \core\output\icon_system::is_valid_system($this->iconsystem)) { 1604 return $this->iconsystem; 1605 } 1606 foreach ($this->parent_configs as $parent_config) { 1607 if (isset($parent_config->iconsystem) && \core\output\icon_system::is_valid_system($parent_config->iconsystem)) { 1608 return $parent_config->iconsystem; 1609 } 1610 } 1611 return \core\output\icon_system::STANDARD; 1612 } 1613 1614 /** 1615 * Return extra SCSS code to add when compiling. 1616 * 1617 * This is intended to be used by themes to inject some SCSS code 1618 * before it gets compiled. If you want to inject variables you 1619 * should use {@link self::get_scss_variables()}. 1620 * 1621 * @return string The SCSS code to inject. 1622 */ 1623 public function get_extra_scss_code() { 1624 $content = ''; 1625 1626 // Getting all the candidate functions. 1627 $candidates = array(); 1628 foreach (array_reverse($this->parent_configs) as $parent_config) { 1629 if (!isset($parent_config->extrascsscallback)) { 1630 continue; 1631 } 1632 $candidates[] = $parent_config->extrascsscallback; 1633 } 1634 1635 if (isset($this->extrascsscallback)) { 1636 $candidates[] = $this->extrascsscallback; 1637 } 1638 1639 // Calling the functions. 1640 foreach ($candidates as $function) { 1641 if (function_exists($function)) { 1642 $content .= "\n/** Extra SCSS from $function **/\n" . $function($this) . "\n"; 1643 } 1644 } 1645 1646 return $content; 1647 } 1648 1649 /** 1650 * SCSS code to prepend when compiling. 1651 * 1652 * This is intended to be used by themes to inject SCSS code before it gets compiled. 1653 * 1654 * @return string The SCSS code to inject. 1655 */ 1656 public function get_pre_scss_code() { 1657 $content = ''; 1658 1659 // Getting all the candidate functions. 1660 $candidates = array(); 1661 foreach (array_reverse($this->parent_configs) as $parent_config) { 1662 if (!isset($parent_config->prescsscallback)) { 1663 continue; 1664 } 1665 $candidates[] = $parent_config->prescsscallback; 1666 } 1667 1668 if (isset($this->prescsscallback)) { 1669 $candidates[] = $this->prescsscallback; 1670 } 1671 1672 // Calling the functions. 1673 foreach ($candidates as $function) { 1674 if (function_exists($function)) { 1675 $content .= "\n/** Pre-SCSS from $function **/\n" . $function($this) . "\n"; 1676 } 1677 } 1678 1679 return $content; 1680 } 1681 1682 /** 1683 * Get the SCSS property. 1684 * 1685 * This resolves whether a SCSS file (or content) has to be used when generating 1686 * the stylesheet for the theme. It will look at parents themes and check the 1687 * SCSS properties there. 1688 * 1689 * @return False when SCSS is not used. 1690 * An array with the import paths, and the path to the SCSS file or Closure as second. 1691 */ 1692 public function get_scss_property() { 1693 if ($this->scsscache === null) { 1694 $configs = [$this] + $this->parent_configs; 1695 $scss = null; 1696 1697 foreach ($configs as $config) { 1698 $path = "{$config->dir}/scss"; 1699 1700 // We collect the SCSS property until we've found one. 1701 if (empty($scss) && !empty($config->scss)) { 1702 $candidate = is_string($config->scss) ? "{$path}/{$config->scss}.scss" : $config->scss; 1703 if ($candidate instanceof Closure) { 1704 $scss = $candidate; 1705 } else if (is_string($candidate) && is_readable($candidate)) { 1706 $scss = $candidate; 1707 } 1708 } 1709 1710 // We collect the import paths once we've found a SCSS property. 1711 if ($scss && is_dir($path)) { 1712 $paths[] = $path; 1713 } 1714 1715 } 1716 1717 $this->scsscache = $scss !== null ? [$paths, $scss] : false; 1718 } 1719 1720 return $this->scsscache; 1721 } 1722 1723 /** 1724 * Generate a URL to the file that serves theme JavaScript files. 1725 * 1726 * If we determine that the theme has no relevant files, then we return 1727 * early with a null value. 1728 * 1729 * @param bool $inhead true means head url, false means footer 1730 * @return moodle_url|null 1731 */ 1732 public function javascript_url($inhead) { 1733 global $CFG; 1734 1735 $rev = theme_get_revision(); 1736 $params = array('theme'=>$this->name,'rev'=>$rev); 1737 $params['type'] = $inhead ? 'head' : 'footer'; 1738 1739 // Return early if there are no files to serve 1740 if (count($this->javascript_files($params['type'])) === 0) { 1741 return null; 1742 } 1743 1744 if (!empty($CFG->slasharguments) and $rev > 0) { 1745 $url = new moodle_url("/theme/javascript.php"); 1746 $url->set_slashargument('/'.$this->name.'/'.$rev.'/'.$params['type'], 'noparam', true); 1747 return $url; 1748 } else { 1749 return new moodle_url('/theme/javascript.php', $params); 1750 } 1751 } 1752 1753 /** 1754 * Get the URL's for the JavaScript files used by this theme. 1755 * They won't be served directly, instead they'll be mediated through 1756 * theme/javascript.php. 1757 * 1758 * @param string $type Either javascripts_footer, or javascripts 1759 * @return array 1760 */ 1761 public function javascript_files($type) { 1762 if ($type === 'footer') { 1763 $type = 'javascripts_footer'; 1764 } else { 1765 $type = 'javascripts'; 1766 } 1767 1768 $js = array(); 1769 // find out wanted parent javascripts 1770 $excludes = $this->resolve_excludes('parents_exclude_javascripts'); 1771 if ($excludes !== true) { 1772 foreach (array_reverse($this->parent_configs) as $parent_config) { // base first, the immediate parent last 1773 $parent = $parent_config->name; 1774 if (empty($parent_config->$type)) { 1775 continue; 1776 } 1777 if (!empty($excludes[$parent]) and $excludes[$parent] === true) { 1778 continue; 1779 } 1780 foreach ($parent_config->$type as $javascript) { 1781 if (!empty($excludes[$parent]) and is_array($excludes[$parent]) 1782 and in_array($javascript, $excludes[$parent])) { 1783 continue; 1784 } 1785 $javascriptfile = "$parent_config->dir/javascript/$javascript.js"; 1786 if (is_readable($javascriptfile)) { 1787 $js[] = $javascriptfile; 1788 } 1789 } 1790 } 1791 } 1792 1793 // current theme javascripts 1794 if (is_array($this->$type)) { 1795 foreach ($this->$type as $javascript) { 1796 $javascriptfile = "$this->dir/javascript/$javascript.js"; 1797 if (is_readable($javascriptfile)) { 1798 $js[] = $javascriptfile; 1799 } 1800 } 1801 } 1802 return $js; 1803 } 1804 1805 /** 1806 * Resolves an exclude setting to the themes setting is applicable or the 1807 * setting of its closest parent. 1808 * 1809 * @param string $variable The name of the setting the exclude setting to resolve 1810 * @param string $default 1811 * @return mixed 1812 */ 1813 protected function resolve_excludes($variable, $default = null) { 1814 $setting = $default; 1815 if (is_array($this->{$variable}) or $this->{$variable} === true) { 1816 $setting = $this->{$variable}; 1817 } else { 1818 foreach ($this->parent_configs as $parent_config) { // the immediate parent first, base last 1819 if (!isset($parent_config->{$variable})) { 1820 continue; 1821 } 1822 if (is_array($parent_config->{$variable}) or $parent_config->{$variable} === true) { 1823 $setting = $parent_config->{$variable}; 1824 break; 1825 } 1826 } 1827 } 1828 return $setting; 1829 } 1830 1831 /** 1832 * Returns the content of the one huge javascript file merged from all theme javascript files. 1833 * 1834 * @param bool $type 1835 * @return string 1836 */ 1837 public function javascript_content($type) { 1838 $jsfiles = $this->javascript_files($type); 1839 $js = ''; 1840 foreach ($jsfiles as $jsfile) { 1841 $js .= file_get_contents($jsfile)."\n"; 1842 } 1843 return $js; 1844 } 1845 1846 /** 1847 * Post processes CSS. 1848 * 1849 * This method post processes all of the CSS before it is served for this theme. 1850 * This is done so that things such as image URL's can be swapped in and to 1851 * run any specific CSS post process method the theme has requested. 1852 * This allows themes to use CSS settings. 1853 * 1854 * @param string $css The CSS to process. 1855 * @return string The processed CSS. 1856 */ 1857 public function post_process($css) { 1858 // now resolve all image locations 1859 if (preg_match_all('/\[\[pix:([a-z0-9_]+\|)?([^\]]+)\]\]/', $css, $matches, PREG_SET_ORDER)) { 1860 $replaced = array(); 1861 foreach ($matches as $match) { 1862 if (isset($replaced[$match[0]])) { 1863 continue; 1864 } 1865 $replaced[$match[0]] = true; 1866 $imagename = $match[2]; 1867 $component = rtrim($match[1], '|'); 1868 $imageurl = $this->image_url($imagename, $component)->out(false); 1869 // we do not need full url because the image.php is always in the same dir 1870 $imageurl = preg_replace('|^http.?://[^/]+|', '', $imageurl); 1871 $css = str_replace($match[0], $imageurl, $css); 1872 } 1873 } 1874 1875 // Now resolve all font locations. 1876 if (preg_match_all('/\[\[font:([a-z0-9_]+\|)?([^\]]+)\]\]/', $css, $matches, PREG_SET_ORDER)) { 1877 $replaced = array(); 1878 foreach ($matches as $match) { 1879 if (isset($replaced[$match[0]])) { 1880 continue; 1881 } 1882 $replaced[$match[0]] = true; 1883 $fontname = $match[2]; 1884 $component = rtrim($match[1], '|'); 1885 $fonturl = $this->font_url($fontname, $component)->out(false); 1886 // We do not need full url because the font.php is always in the same dir. 1887 $fonturl = preg_replace('|^http.?://[^/]+|', '', $fonturl); 1888 $css = str_replace($match[0], $fonturl, $css); 1889 } 1890 } 1891 1892 // Now resolve all theme settings or do any other postprocessing. 1893 // This needs to be done before calling core parser, since the parser strips [[settings]] tags. 1894 $csspostprocess = $this->csspostprocess; 1895 if ($csspostprocess && function_exists($csspostprocess)) { 1896 $css = $csspostprocess($css, $this); 1897 } 1898 1899 // Post processing using an object representation of CSS. 1900 $treeprocessor = $this->get_css_tree_post_processor(); 1901 $needsparsing = !empty($treeprocessor) || !empty($this->rtlmode); 1902 if ($needsparsing) { 1903 1904 // We might need more memory/time to do this, so let's play safe. 1905 raise_memory_limit(MEMORY_EXTRA); 1906 core_php_time_limit::raise(300); 1907 1908 $parser = new core_cssparser($css); 1909 $csstree = $parser->parse(); 1910 unset($parser); 1911 1912 if ($this->rtlmode) { 1913 $this->rtlize($csstree); 1914 } 1915 1916 if ($treeprocessor) { 1917 $treeprocessor($csstree, $this); 1918 } 1919 1920 $css = $csstree->render(); 1921 unset($csstree); 1922 } 1923 1924 return $css; 1925 } 1926 1927 /** 1928 * Flip a stylesheet to RTL. 1929 * 1930 * @param Object $csstree The parsed CSS tree structure to flip. 1931 * @return void 1932 */ 1933 protected function rtlize($csstree) { 1934 $rtlcss = new core_rtlcss($csstree); 1935 $rtlcss->flip(); 1936 } 1937 1938 /** 1939 * Return the direct URL for an image from the pix folder. 1940 * 1941 * Use this function sparingly and never for icons. For icons use pix_icon or the pix helper in a mustache template. 1942 * 1943 * @deprecated since Moodle 3.3 1944 * @param string $imagename the name of the icon. 1945 * @param string $component specification of one plugin like in get_string() 1946 * @return moodle_url 1947 */ 1948 public function pix_url($imagename, $component) { 1949 debugging('pix_url is deprecated. Use image_url for images and pix_icon for icons.', DEBUG_DEVELOPER); 1950 return $this->image_url($imagename, $component); 1951 } 1952 1953 /** 1954 * Return the direct URL for an image from the pix folder. 1955 * 1956 * Use this function sparingly and never for icons. For icons use pix_icon or the pix helper in a mustache template. 1957 * 1958 * @param string $imagename the name of the icon. 1959 * @param string $component specification of one plugin like in get_string() 1960 * @return moodle_url 1961 */ 1962 public function image_url($imagename, $component) { 1963 global $CFG; 1964 1965 $params = array('theme'=>$this->name); 1966 $svg = $this->use_svg_icons(); 1967 1968 if (empty($component) or $component === 'moodle' or $component === 'core') { 1969 $params['component'] = 'core'; 1970 } else { 1971 $params['component'] = $component; 1972 } 1973 1974 $rev = theme_get_revision(); 1975 if ($rev != -1) { 1976 $params['rev'] = $rev; 1977 } 1978 1979 $params['image'] = $imagename; 1980 1981 $url = new moodle_url("/theme/image.php"); 1982 if (!empty($CFG->slasharguments) and $rev > 0) { 1983 $path = '/'.$params['theme'].'/'.$params['component'].'/'.$params['rev'].'/'.$params['image']; 1984 if (!$svg) { 1985 // We add a simple /_s to the start of the path. 1986 // The underscore is used to ensure that it isn't a valid theme name. 1987 $path = '/_s'.$path; 1988 } 1989 $url->set_slashargument($path, 'noparam', true); 1990 } else { 1991 if (!$svg) { 1992 // We add an SVG param so that we know not to serve SVG images. 1993 // We do this because all modern browsers support SVG and this param will one day be removed. 1994 $params['svg'] = '0'; 1995 } 1996 $url->params($params); 1997 } 1998 1999 return $url; 2000 } 2001 2002 /** 2003 * Return the URL for a font 2004 * 2005 * @param string $font the name of the font (including extension). 2006 * @param string $component specification of one plugin like in get_string() 2007 * @return moodle_url 2008 */ 2009 public function font_url($font, $component) { 2010 global $CFG; 2011 2012 $params = array('theme'=>$this->name); 2013 2014 if (empty($component) or $component === 'moodle' or $component === 'core') { 2015 $params['component'] = 'core'; 2016 } else { 2017 $params['component'] = $component; 2018 } 2019 2020 $rev = theme_get_revision(); 2021 if ($rev != -1) { 2022 $params['rev'] = $rev; 2023 } 2024 2025 $params['font'] = $font; 2026 2027 $url = new moodle_url("/theme/font.php"); 2028 if (!empty($CFG->slasharguments) and $rev > 0) { 2029 $path = '/'.$params['theme'].'/'.$params['component'].'/'.$params['rev'].'/'.$params['font']; 2030 $url->set_slashargument($path, 'noparam', true); 2031 } else { 2032 $url->params($params); 2033 } 2034 2035 return $url; 2036 } 2037 2038 /** 2039 * Returns URL to the stored file via pluginfile.php. 2040 * 2041 * Note the theme must also implement pluginfile.php handler, 2042 * theme revision is used instead of the itemid. 2043 * 2044 * @param string $setting 2045 * @param string $filearea 2046 * @return string protocol relative URL or null if not present 2047 */ 2048 public function setting_file_url($setting, $filearea) { 2049 global $CFG; 2050 2051 if (empty($this->settings->$setting)) { 2052 return null; 2053 } 2054 2055 $component = 'theme_'.$this->name; 2056 $itemid = theme_get_revision(); 2057 $filepath = $this->settings->$setting; 2058 $syscontext = context_system::instance(); 2059 2060 $url = moodle_url::make_file_url("$CFG->wwwroot/pluginfile.php", "/$syscontext->id/$component/$filearea/$itemid".$filepath); 2061 2062 // Now this is tricky because the we can not hardcode http or https here, lets use the relative link. 2063 // Note: unfortunately moodle_url does not support //urls yet. 2064 2065 $url = preg_replace('|^https?://|i', '//', $url->out(false)); 2066 2067 return $url; 2068 } 2069 2070 /** 2071 * Serve the theme setting file. 2072 * 2073 * @param string $filearea 2074 * @param array $args 2075 * @param bool $forcedownload 2076 * @param array $options 2077 * @return bool may terminate if file not found or donotdie not specified 2078 */ 2079 public function setting_file_serve($filearea, $args, $forcedownload, $options) { 2080 global $CFG; 2081 require_once("$CFG->libdir/filelib.php"); 2082 2083 $syscontext = context_system::instance(); 2084 $component = 'theme_'.$this->name; 2085 2086 $revision = array_shift($args); 2087 if ($revision < 0) { 2088 $lifetime = 0; 2089 } else { 2090 $lifetime = 60*60*24*60; 2091 // By default, theme files must be cache-able by both browsers and proxies. 2092 if (!array_key_exists('cacheability', $options)) { 2093 $options['cacheability'] = 'public'; 2094 } 2095 } 2096 2097 $fs = get_file_storage(); 2098 $relativepath = implode('/', $args); 2099 2100 $fullpath = "/{$syscontext->id}/{$component}/{$filearea}/0/{$relativepath}"; 2101 $fullpath = rtrim($fullpath, '/'); 2102 if ($file = $fs->get_file_by_hash(sha1($fullpath))) { 2103 send_stored_file($file, $lifetime, 0, $forcedownload, $options); 2104 return true; 2105 } else { 2106 send_file_not_found(); 2107 } 2108 } 2109 2110 /** 2111 * Resolves the real image location. 2112 * 2113 * $svg was introduced as an arg in 2.4. It is important because not all supported browsers support the use of SVG 2114 * and we need a way in which to turn it off. 2115 * By default SVG won't be used unless asked for. This is done for two reasons: 2116 * 1. It ensures that we don't serve svg images unless we really want to. The admin has selected to force them, of the users 2117 * browser supports SVG. 2118 * 2. We only serve SVG images from locations we trust. This must NOT include any areas where the image may have been uploaded 2119 * by the user due to security concerns. 2120 * 2121 * @param string $image name of image, may contain relative path 2122 * @param string $component 2123 * @param bool $svg|null Should SVG images also be looked for? If null, resorts to $CFG->svgicons if that is set; falls back to 2124 * auto-detection of browser support otherwise 2125 * @return string full file path 2126 */ 2127 public function resolve_image_location($image, $component, $svg = false) { 2128 global $CFG; 2129 2130 if (!is_bool($svg)) { 2131 // If $svg isn't a bool then we need to decide for ourselves. 2132 $svg = $this->use_svg_icons(); 2133 } 2134 2135 if ($component === 'moodle' or $component === 'core' or empty($component)) { 2136 if ($imagefile = $this->image_exists("$this->dir/pix_core/$image", $svg)) { 2137 return $imagefile; 2138 } 2139 foreach (array_reverse($this->parent_configs) as $parent_config) { // base first, the immediate parent last 2140 if ($imagefile = $this->image_exists("$parent_config->dir/pix_core/$image", $svg)) { 2141 return $imagefile; 2142 } 2143 } 2144 if ($imagefile = $this->image_exists("$CFG->dataroot/pix/$image", $svg)) { 2145 return $imagefile; 2146 } 2147 if ($imagefile = $this->image_exists("$CFG->dirroot/pix/$image", $svg)) { 2148 return $imagefile; 2149 } 2150 return null; 2151 2152 } else if ($component === 'theme') { //exception 2153 if ($image === 'favicon') { 2154 return "$this->dir/pix/favicon.ico"; 2155 } 2156 if ($imagefile = $this->image_exists("$this->dir/pix/$image", $svg)) { 2157 return $imagefile; 2158 } 2159 foreach (array_reverse($this->parent_configs) as $parent_config) { // base first, the immediate parent last 2160 if ($imagefile = $this->image_exists("$parent_config->dir/pix/$image", $svg)) { 2161 return $imagefile; 2162 } 2163 } 2164 return null; 2165 2166 } else { 2167 if (strpos($component, '_') === false) { 2168 $component = "mod_{$component}"; 2169 } 2170 list($type, $plugin) = explode('_', $component, 2); 2171 2172 // In Moodle 4.0 we introduced a new image format. 2173 // Support that image format here. 2174 $candidates = [$image]; 2175 2176 if ($type === 'mod') { 2177 if ($image === 'icon' || $image === 'monologo') { 2178 $candidates = ['monologo', 'icon']; 2179 if ($image === 'icon') { 2180 debugging( 2181 "The 'icon' image for activity modules has been replaced with a new 'monologo'. " . 2182 "Please update your calling code to fetch the new icon where possible. " . 2183 "Called for component {$component}.", 2184 DEBUG_DEVELOPER 2185 ); 2186 } 2187 } 2188 } 2189 foreach ($candidates as $image) { 2190 if ($imagefile = $this->image_exists("$this->dir/pix_plugins/$type/$plugin/$image", $svg)) { 2191 return $imagefile; 2192 } 2193 2194 // Base first, the immediate parent last. 2195 foreach (array_reverse($this->parent_configs) as $parentconfig) { 2196 if ($imagefile = $this->image_exists("$parentconfig->dir/pix_plugins/$type/$plugin/$image", $svg)) { 2197 return $imagefile; 2198 } 2199 } 2200 if ($imagefile = $this->image_exists("$CFG->dataroot/pix_plugins/$type/$plugin/$image", $svg)) { 2201 return $imagefile; 2202 } 2203 $dir = core_component::get_plugin_directory($type, $plugin); 2204 if ($imagefile = $this->image_exists("$dir/pix/$image", $svg)) { 2205 return $imagefile; 2206 } 2207 } 2208 return null; 2209 } 2210 } 2211 2212 /** 2213 * Resolves the real font location. 2214 * 2215 * @param string $font name of font file 2216 * @param string $component 2217 * @return string full file path 2218 */ 2219 public function resolve_font_location($font, $component) { 2220 global $CFG; 2221 2222 if ($component === 'moodle' or $component === 'core' or empty($component)) { 2223 if (file_exists("$this->dir/fonts_core/$font")) { 2224 return "$this->dir/fonts_core/$font"; 2225 } 2226 foreach (array_reverse($this->parent_configs) as $parent_config) { // Base first, the immediate parent last. 2227 if (file_exists("$parent_config->dir/fonts_core/$font")) { 2228 return "$parent_config->dir/fonts_core/$font"; 2229 } 2230 } 2231 if (file_exists("$CFG->dataroot/fonts/$font")) { 2232 return "$CFG->dataroot/fonts/$font"; 2233 } 2234 if (file_exists("$CFG->dirroot/lib/fonts/$font")) { 2235 return "$CFG->dirroot/lib/fonts/$font"; 2236 } 2237 return null; 2238 2239 } else if ($component === 'theme') { // Exception. 2240 if (file_exists("$this->dir/fonts/$font")) { 2241 return "$this->dir/fonts/$font"; 2242 } 2243 foreach (array_reverse($this->parent_configs) as $parent_config) { // Base first, the immediate parent last. 2244 if (file_exists("$parent_config->dir/fonts/$font")) { 2245 return "$parent_config->dir/fonts/$font"; 2246 } 2247 } 2248 return null; 2249 2250 } else { 2251 if (strpos($component, '_') === false) { 2252 $component = 'mod_'.$component; 2253 } 2254 list($type, $plugin) = explode('_', $component, 2); 2255 2256 if (file_exists("$this->dir/fonts_plugins/$type/$plugin/$font")) { 2257 return "$this->dir/fonts_plugins/$type/$plugin/$font"; 2258 } 2259 foreach (array_reverse($this->parent_configs) as $parent_config) { // Base first, the immediate parent last. 2260 if (file_exists("$parent_config->dir/fonts_plugins/$type/$plugin/$font")) { 2261 return "$parent_config->dir/fonts_plugins/$type/$plugin/$font"; 2262 } 2263 } 2264 if (file_exists("$CFG->dataroot/fonts_plugins/$type/$plugin/$font")) { 2265 return "$CFG->dataroot/fonts_plugins/$type/$plugin/$font"; 2266 } 2267 $dir = core_component::get_plugin_directory($type, $plugin); 2268 if (file_exists("$dir/fonts/$font")) { 2269 return "$dir/fonts/$font"; 2270 } 2271 return null; 2272 } 2273 } 2274 2275 /** 2276 * Return true if we should look for SVG images as well. 2277 * 2278 * @return bool 2279 */ 2280 public function use_svg_icons() { 2281 global $CFG; 2282 if ($this->usesvg === null) { 2283 2284 if (!isset($CFG->svgicons)) { 2285 $this->usesvg = core_useragent::supports_svg(); 2286 } else { 2287 // Force them on/off depending upon the setting. 2288 $this->usesvg = (bool)$CFG->svgicons; 2289 } 2290 } 2291 return $this->usesvg; 2292 } 2293 2294 /** 2295 * Forces the usesvg setting to either true or false, avoiding any decision making. 2296 * 2297 * This function should only ever be used when absolutely required, and before any generation of image URL's has occurred. 2298 * DO NOT ABUSE THIS FUNCTION... not that you'd want to right ;) 2299 * 2300 * @param bool $setting True to force the use of svg when available, null otherwise. 2301 */ 2302 public function force_svg_use($setting) { 2303 $this->usesvg = (bool)$setting; 2304 } 2305 2306 /** 2307 * Set to be in RTL mode. 2308 * 2309 * This will likely be used when post processing the CSS before serving it. 2310 * 2311 * @param bool $inrtl True when in RTL mode. 2312 */ 2313 public function set_rtl_mode($inrtl = true) { 2314 $this->rtlmode = $inrtl; 2315 } 2316 2317 /** 2318 * Checks if source maps are supported 2319 * 2320 * @param bool $themedesigner True if theme designer is enabled. 2321 * @return boolean True if source maps are supported. 2322 */ 2323 public function supports_source_maps($themedesigner): bool { 2324 if (empty($this->rtlmode) && $themedesigner) { 2325 return true; 2326 } 2327 return false; 2328 } 2329 2330 /** 2331 * Whether the theme is being served in RTL mode. 2332 * 2333 * @return bool True when in RTL mode. 2334 */ 2335 public function get_rtl_mode() { 2336 return $this->rtlmode; 2337 } 2338 2339 /** 2340 * Checks if file with any image extension exists. 2341 * 2342 * The order to these images was adjusted prior to the release of 2.4 2343 * At that point the were the following image counts in Moodle core: 2344 * 2345 * - png = 667 in pix dirs (1499 total) 2346 * - gif = 385 in pix dirs (606 total) 2347 * - jpg = 62 in pix dirs (74 total) 2348 * - jpeg = 0 in pix dirs (1 total) 2349 * 2350 * There is work in progress to move towards SVG presently hence that has been prioritiesed. 2351 * 2352 * @param string $filepath 2353 * @param bool $svg If set to true SVG images will also be looked for. 2354 * @return string image name with extension 2355 */ 2356 private static function image_exists($filepath, $svg = false) { 2357 if ($svg && file_exists("$filepath.svg")) { 2358 return "$filepath.svg"; 2359 } else if (file_exists("$filepath.png")) { 2360 return "$filepath.png"; 2361 } else if (file_exists("$filepath.gif")) { 2362 return "$filepath.gif"; 2363 } else if (file_exists("$filepath.jpg")) { 2364 return "$filepath.jpg"; 2365 } else if (file_exists("$filepath.jpeg")) { 2366 return "$filepath.jpeg"; 2367 } else { 2368 return false; 2369 } 2370 } 2371 2372 /** 2373 * Loads the theme config from config.php file. 2374 * 2375 * @param string $themename 2376 * @param stdClass $settings from config_plugins table 2377 * @param boolean $parentscheck true to also check the parents. . 2378 * @return stdClass The theme configuration 2379 */ 2380 private static function find_theme_config($themename, $settings, $parentscheck = true) { 2381 // We have to use the variable name $THEME (upper case) because that 2382 // is what is used in theme config.php files. 2383 2384 if (!$dir = theme_config::find_theme_location($themename)) { 2385 return null; 2386 } 2387 2388 $THEME = new stdClass(); 2389 $THEME->name = $themename; 2390 $THEME->dir = $dir; 2391 $THEME->settings = $settings; 2392 2393 global $CFG; // just in case somebody tries to use $CFG in theme config 2394 include("$THEME->dir/config.php"); 2395 2396 // verify the theme configuration is OK 2397 if (!is_array($THEME->parents)) { 2398 // parents option is mandatory now 2399 return null; 2400 } else { 2401 // We use $parentscheck to only check the direct parents (avoid infinite loop). 2402 if ($parentscheck) { 2403 // Find all parent theme configs. 2404 foreach ($THEME->parents as $parent) { 2405 $parentconfig = theme_config::find_theme_config($parent, $settings, false); 2406 if (empty($parentconfig)) { 2407 return null; 2408 } 2409 } 2410 } 2411 } 2412 2413 return $THEME; 2414 } 2415 2416 /** 2417 * Finds the theme location and verifies the theme has all needed files 2418 * and is not obsoleted. 2419 * 2420 * @param string $themename 2421 * @return string full dir path or null if not found 2422 */ 2423 private static function find_theme_location($themename) { 2424 global $CFG; 2425 2426 if (file_exists("$CFG->dirroot/theme/$themename/config.php")) { 2427 $dir = "$CFG->dirroot/theme/$themename"; 2428 2429 } else if (!empty($CFG->themedir) and file_exists("$CFG->themedir/$themename/config.php")) { 2430 $dir = "$CFG->themedir/$themename"; 2431 2432 } else { 2433 return null; 2434 } 2435 2436 if (file_exists("$dir/styles.php")) { 2437 //legacy theme - needs to be upgraded - upgrade info is displayed on the admin settings page 2438 return null; 2439 } 2440 2441 return $dir; 2442 } 2443 2444 /** 2445 * Get the renderer for a part of Moodle for this theme. 2446 * 2447 * @param moodle_page $page the page we are rendering 2448 * @param string $component the name of part of moodle. E.g. 'core', 'quiz', 'qtype_multichoice'. 2449 * @param string $subtype optional subtype such as 'news' resulting to 'mod_forum_news' 2450 * @param string $target one of rendering target constants 2451 * @return renderer_base the requested renderer. 2452 */ 2453 public function get_renderer(moodle_page $page, $component, $subtype = null, $target = null) { 2454 if (is_null($this->rf)) { 2455 $classname = $this->rendererfactory; 2456 $this->rf = new $classname($this); 2457 } 2458 2459 return $this->rf->get_renderer($page, $component, $subtype, $target); 2460 } 2461 2462 /** 2463 * Get the information from {@link $layouts} for this type of page. 2464 * 2465 * @param string $pagelayout the the page layout name. 2466 * @return array the appropriate part of {@link $layouts}. 2467 */ 2468 protected function layout_info_for_page($pagelayout) { 2469 if (array_key_exists($pagelayout, $this->layouts)) { 2470 return $this->layouts[$pagelayout]; 2471 } else { 2472 debugging('Invalid page layout specified: ' . $pagelayout); 2473 return $this->layouts['standard']; 2474 } 2475 } 2476 2477 /** 2478 * Given the settings of this theme, and the page pagelayout, return the 2479 * full path of the page layout file to use. 2480 * 2481 * Used by {@link core_renderer::header()}. 2482 * 2483 * @param string $pagelayout the the page layout name. 2484 * @return string Full path to the lyout file to use 2485 */ 2486 public function layout_file($pagelayout) { 2487 global $CFG; 2488 2489 $layoutinfo = $this->layout_info_for_page($pagelayout); 2490 $layoutfile = $layoutinfo['file']; 2491 2492 if (array_key_exists('theme', $layoutinfo)) { 2493 $themes = array($layoutinfo['theme']); 2494 } else { 2495 $themes = array_merge(array($this->name),$this->parents); 2496 } 2497 2498 foreach ($themes as $theme) { 2499 if ($dir = $this->find_theme_location($theme)) { 2500 $path = "$dir/layout/$layoutfile"; 2501 2502 // Check the template exists, return general base theme template if not. 2503 if (is_readable($path)) { 2504 return $path; 2505 } 2506 } 2507 } 2508 2509 debugging('Can not find layout file for: ' . $pagelayout); 2510 // fallback to standard normal layout 2511 return "$CFG->dirroot/theme/base/layout/general.php"; 2512 } 2513 2514 /** 2515 * Returns auxiliary page layout options specified in layout configuration array. 2516 * 2517 * @param string $pagelayout 2518 * @return array 2519 */ 2520 public function pagelayout_options($pagelayout) { 2521 $info = $this->layout_info_for_page($pagelayout); 2522 if (!empty($info['options'])) { 2523 return $info['options']; 2524 } 2525 return array(); 2526 } 2527 2528 /** 2529 * Inform a block_manager about the block regions this theme wants on this 2530 * page layout. 2531 * 2532 * @param string $pagelayout the general type of the page. 2533 * @param block_manager $blockmanager the block_manger to set up. 2534 */ 2535 public function setup_blocks($pagelayout, $blockmanager) { 2536 $layoutinfo = $this->layout_info_for_page($pagelayout); 2537 if (!empty($layoutinfo['regions'])) { 2538 $blockmanager->add_regions($layoutinfo['regions'], false); 2539 $blockmanager->set_default_region($layoutinfo['defaultregion']); 2540 } 2541 } 2542 2543 /** 2544 * Gets the visible name for the requested block region. 2545 * 2546 * @param string $region The region name to get 2547 * @param string $theme The theme the region belongs to (may come from the parent theme) 2548 * @return string 2549 */ 2550 protected function get_region_name($region, $theme) { 2551 2552 $stringman = get_string_manager(); 2553 2554 // Check if the name is defined in the theme. 2555 if ($stringman->string_exists('region-' . $region, 'theme_' . $theme)) { 2556 return get_string('region-' . $region, 'theme_' . $theme); 2557 } 2558 2559 // Check the theme parents. 2560 foreach ($this->parents as $parentthemename) { 2561 if ($stringman->string_exists('region-' . $region, 'theme_' . $parentthemename)) { 2562 return get_string('region-' . $region, 'theme_' . $parentthemename); 2563 } 2564 } 2565 2566 // Last resort, try the boost theme for names. 2567 return get_string('region-' . $region, 'theme_boost'); 2568 } 2569 2570 /** 2571 * Get the list of all block regions known to this theme in all templates. 2572 * 2573 * @return array internal region name => human readable name. 2574 */ 2575 public function get_all_block_regions() { 2576 $regions = array(); 2577 foreach ($this->layouts as $layoutinfo) { 2578 foreach ($layoutinfo['regions'] as $region) { 2579 $regions[$region] = $this->get_region_name($region, $this->name); 2580 } 2581 } 2582 return $regions; 2583 } 2584 2585 /** 2586 * Returns the human readable name of the theme 2587 * 2588 * @return string 2589 */ 2590 public function get_theme_name() { 2591 return get_string('pluginname', 'theme_'.$this->name); 2592 } 2593 2594 /** 2595 * Returns the block render method. 2596 * 2597 * It is set by the theme via: 2598 * $THEME->blockrendermethod = '...'; 2599 * 2600 * It can be one of two values, blocks or blocks_for_region. 2601 * It should be set to the method being used by the theme layouts. 2602 * 2603 * @return string 2604 */ 2605 public function get_block_render_method() { 2606 if ($this->blockrendermethod) { 2607 // Return the specified block render method. 2608 return $this->blockrendermethod; 2609 } 2610 // Its not explicitly set, check the parent theme configs. 2611 foreach ($this->parent_configs as $config) { 2612 if (isset($config->blockrendermethod)) { 2613 return $config->blockrendermethod; 2614 } 2615 } 2616 // Default it to blocks. 2617 return 'blocks'; 2618 } 2619 2620 /** 2621 * Get the callable for CSS tree post processing. 2622 * 2623 * @return string|null 2624 */ 2625 public function get_css_tree_post_processor() { 2626 $configs = [$this] + $this->parent_configs; 2627 foreach ($configs as $config) { 2628 if (!empty($config->csstreepostprocessor) && is_callable($config->csstreepostprocessor)) { 2629 return $config->csstreepostprocessor; 2630 } 2631 } 2632 return null; 2633 } 2634 2635 } 2636 2637 /** 2638 * This class keeps track of which HTML tags are currently open. 2639 * 2640 * This makes it much easier to always generate well formed XHTML output, even 2641 * if execution terminates abruptly. Any time you output some opening HTML 2642 * without the matching closing HTML, you should push the necessary close tags 2643 * onto the stack. 2644 * 2645 * @copyright 2009 Tim Hunt 2646 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later 2647 * @since Moodle 2.0 2648 * @package core 2649 * @category output 2650 */ 2651 class xhtml_container_stack { 2652 2653 /** 2654 * @var array Stores the list of open containers. 2655 */ 2656 protected $opencontainers = array(); 2657 2658 /** 2659 * @var array In developer debug mode, stores a stack trace of all opens and 2660 * closes, so we can output helpful error messages when there is a mismatch. 2661 */ 2662 protected $log = array(); 2663 2664 /** 2665 * @var boolean Store whether we are developer debug mode. We need this in 2666 * several places including in the destructor where we may not have access to $CFG. 2667 */ 2668 protected $isdebugging; 2669 2670 /** 2671 * Constructor 2672 */ 2673 public function __construct() { 2674 global $CFG; 2675 $this->isdebugging = $CFG->debugdeveloper; 2676 } 2677 2678 /** 2679 * Push the close HTML for a recently opened container onto the stack. 2680 * 2681 * @param string $type The type of container. This is checked when {@link pop()} 2682 * is called and must match, otherwise a developer debug warning is output. 2683 * @param string $closehtml The HTML required to close the container. 2684 */ 2685 public function push($type, $closehtml) { 2686 $container = new stdClass; 2687 $container->type = $type; 2688 $container->closehtml = $closehtml; 2689 if ($this->isdebugging) { 2690 $this->log('Open', $type); 2691 } 2692 array_push($this->opencontainers, $container); 2693 } 2694 2695 /** 2696 * Pop the HTML for the next closing container from the stack. The $type 2697 * must match the type passed when the container was opened, otherwise a 2698 * warning will be output. 2699 * 2700 * @param string $type The type of container. 2701 * @return string the HTML required to close the container. 2702 */ 2703 public function pop($type) { 2704 if (empty($this->opencontainers)) { 2705 debugging('<p>There are no more open containers. This suggests there is a nesting problem.</p>' . 2706 $this->output_log(), DEBUG_DEVELOPER); 2707 return; 2708 } 2709 2710 $container = array_pop($this->opencontainers); 2711 if ($container->type != $type) { 2712 debugging('<p>The type of container to be closed (' . $container->type . 2713 ') does not match the type of the next open container (' . $type . 2714 '). This suggests there is a nesting problem.</p>' . 2715 $this->output_log(), DEBUG_DEVELOPER); 2716 } 2717 if ($this->isdebugging) { 2718 $this->log('Close', $type); 2719 } 2720 return $container->closehtml; 2721 } 2722 2723 /** 2724 * Close all but the last open container. This is useful in places like error 2725 * handling, where you want to close all the open containers (apart from <body>) 2726 * before outputting the error message. 2727 * 2728 * @param bool $shouldbenone assert that the stack should be empty now - causes a 2729 * developer debug warning if it isn't. 2730 * @return string the HTML required to close any open containers inside <body>. 2731 */ 2732 public function pop_all_but_last($shouldbenone = false) { 2733 if ($shouldbenone && count($this->opencontainers) != 1) { 2734 debugging('<p>Some HTML tags were opened in the body of the page but not closed.</p>' . 2735 $this->output_log(), DEBUG_DEVELOPER); 2736 } 2737 $output = ''; 2738 while (count($this->opencontainers) > 1) { 2739 $container = array_pop($this->opencontainers); 2740 $output .= $container->closehtml; 2741 } 2742 return $output; 2743 } 2744 2745 /** 2746 * You can call this function if you want to throw away an instance of this 2747 * class without properly emptying the stack (for example, in a unit test). 2748 * Calling this method stops the destruct method from outputting a developer 2749 * debug warning. After calling this method, the instance can no longer be used. 2750 */ 2751 public function discard() { 2752 $this->opencontainers = null; 2753 } 2754 2755 /** 2756 * Adds an entry to the log. 2757 * 2758 * @param string $action The name of the action 2759 * @param string $type The type of action 2760 */ 2761 protected function log($action, $type) { 2762 $this->log[] = '<li>' . $action . ' ' . $type . ' at:' . 2763 format_backtrace(debug_backtrace()) . '</li>'; 2764 } 2765 2766 /** 2767 * Outputs the log's contents as a HTML list. 2768 * 2769 * @return string HTML list of the log 2770 */ 2771 protected function output_log() { 2772 return '<ul>' . implode("\n", $this->log) . '</ul>'; 2773 } 2774 }
title
Description
Body
title
Description
Body
title
Description
Body
title
Body
