Search moodle.org's
Developer Documentation
Developer Documentation
- Bug fixes for general core bugs in 3.11.x will end 14 Nov 2022 (12 months plus 6 months extension).
- Bug fixes for security issues in 3.11.x will end 13 Nov 2023 (18 months plus 12 months extension).
- PHP version: minimum PHP 7.3.0 Note: minimum PHP version has increased since Moodle 3.10. PHP 7.4.x is supported too.
/lib/ -> outputlib.php (source)
Differences Between: [Versions 310 and 311] [Versions 311 and 400] [Versions 311 and 401] [Versions 311 and 402] [Versions 311 and 403] [Versions 39 and 311]
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 * Load the config.php file for a particular theme, and return an instance 682 * of this class. (That is, this is a factory method.) 683 * 684 * @param string $themename the name of the theme. 685 * @return theme_config an instance of this class. 686 */ 687 public static function load($themename) { 688 global $CFG; 689 690 // load theme settings from db 691 try { 692 $settings = get_config('theme_'.$themename); 693 } catch (dml_exception $e) { 694 // most probably moodle tables not created yet 695 $settings = new stdClass(); 696 } 697 698 if ($config = theme_config::find_theme_config($themename, $settings)) { 699 return new theme_config($config); 700 701 } else if ($themename == theme_config::DEFAULT_THEME) { 702 throw new coding_exception('Default theme '.theme_config::DEFAULT_THEME.' not available or broken!'); 703 704 } else if ($config = theme_config::find_theme_config($CFG->theme, $settings)) { 705 debugging('This page should be using theme ' . $themename . 706 ' which cannot be initialised. Falling back to the site theme ' . $CFG->theme, DEBUG_NORMAL); 707 return new theme_config($config); 708 709 } else { 710 // bad luck, the requested theme has some problems - admin see details in theme config 711 debugging('This page should be using theme ' . $themename . 712 ' which cannot be initialised. Nor can the site theme ' . $CFG->theme . 713 '. Falling back to ' . theme_config::DEFAULT_THEME, DEBUG_NORMAL); 714 return new theme_config(theme_config::find_theme_config(theme_config::DEFAULT_THEME, $settings)); 715 } 716 } 717 718 /** 719 * Theme diagnostic code. It is very problematic to send debug output 720 * to the actual CSS file, instead this functions is supposed to 721 * diagnose given theme and highlights all potential problems. 722 * This information should be available from the theme selection page 723 * or some other debug page for theme designers. 724 * 725 * @param string $themename 726 * @return array description of problems 727 */ 728 public static function diagnose($themename) { 729 //TODO: MDL-21108 730 return array(); 731 } 732 733 /** 734 * Private constructor, can be called only from the factory method. 735 * @param stdClass $config 736 */ 737 private function __construct($config) { 738 global $CFG; //needed for included lib.php files 739 740 $this->settings = $config->settings; 741 $this->name = $config->name; 742 $this->dir = $config->dir; 743 744 if ($this->name != self::DEFAULT_THEME) { 745 $baseconfig = self::find_theme_config(self::DEFAULT_THEME, $this->settings); 746 } else { 747 $baseconfig = $config; 748 } 749 750 $configurable = array( 751 'parents', 'sheets', 'parents_exclude_sheets', 'plugins_exclude_sheets', 'usefallback', 752 'javascripts', 'javascripts_footer', 'parents_exclude_javascripts', 753 'layouts', 'enablecourseajax', 'requiredblocks', 754 'rendererfactory', 'csspostprocess', 'editor_sheets', 'editor_scss', 'rarrow', 'larrow', 'uarrow', 'darrow', 755 'hidefromselector', 'doctype', 'yuicssmodules', 'blockrtlmanipulations', 'blockrendermethod', 756 'scss', 'extrascsscallback', 'prescsscallback', 'csstreepostprocessor', 'addblockposition', 757 'iconsystem', 'precompiledcsscallback'); 758 759 foreach ($config as $key=>$value) { 760 if (in_array($key, $configurable)) { 761 $this->$key = $value; 762 } 763 } 764 765 // verify all parents and load configs and renderers 766 foreach ($this->parents as $parent) { 767 if (!$parent_config = theme_config::find_theme_config($parent, $this->settings)) { 768 // this is not good - better exclude faulty parents 769 continue; 770 } 771 $libfile = $parent_config->dir.'/lib.php'; 772 if (is_readable($libfile)) { 773 // theme may store various function here 774 include_once($libfile); 775 } 776 $renderersfile = $parent_config->dir.'/renderers.php'; 777 if (is_readable($renderersfile)) { 778 // may contain core and plugin renderers and renderer factory 779 include_once($renderersfile); 780 } 781 $this->parent_configs[$parent] = $parent_config; 782 } 783 $libfile = $this->dir.'/lib.php'; 784 if (is_readable($libfile)) { 785 // theme may store various function here 786 include_once($libfile); 787 } 788 $rendererfile = $this->dir.'/renderers.php'; 789 if (is_readable($rendererfile)) { 790 // may contain core and plugin renderers and renderer factory 791 include_once($rendererfile); 792 } else { 793 // check if renderers.php file is missnamed renderer.php 794 if (is_readable($this->dir.'/renderer.php')) { 795 debugging('Developer hint: '.$this->dir.'/renderer.php should be renamed to ' . $this->dir."/renderers.php. 796 See: http://docs.moodle.org/dev/Output_renderers#Theme_renderers.", DEBUG_DEVELOPER); 797 } 798 } 799 800 // cascade all layouts properly 801 foreach ($baseconfig->layouts as $layout=>$value) { 802 if (!isset($this->layouts[$layout])) { 803 foreach ($this->parent_configs as $parent_config) { 804 if (isset($parent_config->layouts[$layout])) { 805 $this->layouts[$layout] = $parent_config->layouts[$layout]; 806 continue 2; 807 } 808 } 809 $this->layouts[$layout] = $value; 810 } 811 } 812 813 //fix arrows if needed 814 $this->check_theme_arrows(); 815 } 816 817 /** 818 * Let the theme initialise the page object (usually $PAGE). 819 * 820 * This may be used for example to request jQuery in add-ons. 821 * 822 * @param moodle_page $page 823 */ 824 public function init_page(moodle_page $page) { 825 $themeinitfunction = 'theme_'.$this->name.'_page_init'; 826 if (function_exists($themeinitfunction)) { 827 $themeinitfunction($page); 828 } 829 } 830 831 /** 832 * Checks if arrows $THEME->rarrow, $THEME->larrow, $THEME->uarrow, $THEME->darrow have been set (theme/-/config.php). 833 * If not it applies sensible defaults. 834 * 835 * Accessibility: right and left arrow Unicode characters for breadcrumb, calendar, 836 * search forum block, etc. Important: these are 'silent' in a screen-reader 837 * (unlike > »), and must be accompanied by text. 838 */ 839 private function check_theme_arrows() { 840 if (!isset($this->rarrow) and !isset($this->larrow)) { 841 // Default, looks good in Win XP/IE 6, Win/Firefox 1.5, Win/Netscape 8... 842 // Also OK in Win 9x/2K/IE 5.x 843 $this->rarrow = '►'; 844 $this->larrow = '◄'; 845 $this->uarrow = '▲'; 846 $this->darrow = '▼'; 847 if (empty($_SERVER['HTTP_USER_AGENT'])) { 848 $uagent = ''; 849 } else { 850 $uagent = $_SERVER['HTTP_USER_AGENT']; 851 } 852 if (false !== strpos($uagent, 'Opera') 853 || false !== strpos($uagent, 'Mac')) { 854 // Looks good in Win XP/Mac/Opera 8/9, Mac/Firefox 2, Camino, Safari. 855 // Not broken in Mac/IE 5, Mac/Netscape 7 (?). 856 $this->rarrow = '▶︎'; 857 $this->larrow = '◀︎'; 858 } 859 elseif ((false !== strpos($uagent, 'Konqueror')) 860 || (false !== strpos($uagent, 'Android'))) { 861 // The fonts on Android don't include the characters required for this to work as expected. 862 // So we use the same ones Konqueror uses. 863 $this->rarrow = '→'; 864 $this->larrow = '←'; 865 $this->uarrow = '↑'; 866 $this->darrow = '↓'; 867 } 868 elseif (isset($_SERVER['HTTP_ACCEPT_CHARSET']) 869 && false === stripos($_SERVER['HTTP_ACCEPT_CHARSET'], 'utf-8')) { 870 // (Win/IE 5 doesn't set ACCEPT_CHARSET, but handles Unicode.) 871 // To be safe, non-Unicode browsers! 872 $this->rarrow = '>'; 873 $this->larrow = '<'; 874 $this->uarrow = '^'; 875 $this->darrow = 'v'; 876 } 877 878 // RTL support - in RTL languages, swap r and l arrows 879 if (right_to_left()) { 880 $t = $this->rarrow; 881 $this->rarrow = $this->larrow; 882 $this->larrow = $t; 883 } 884 } 885 } 886 887 /** 888 * Returns output renderer prefixes, these are used when looking 889 * for the overridden renderers in themes. 890 * 891 * @return array 892 */ 893 public function renderer_prefixes() { 894 global $CFG; // just in case the included files need it 895 896 $prefixes = array('theme_'.$this->name); 897 898 foreach ($this->parent_configs as $parent) { 899 $prefixes[] = 'theme_'.$parent->name; 900 } 901 902 return $prefixes; 903 } 904 905 /** 906 * Returns the stylesheet URL of this editor content 907 * 908 * @param bool $encoded false means use & and true use & in URLs 909 * @return moodle_url 910 */ 911 public function editor_css_url($encoded=true) { 912 global $CFG; 913 $rev = theme_get_revision(); 914 if ($rev > -1) { 915 $themesubrevision = theme_get_sub_revision_for_theme($this->name); 916 917 // Provide the sub revision to allow us to invalidate cached theme CSS 918 // on a per theme basis, rather than globally. 919 if ($themesubrevision && $themesubrevision > 0) { 920 $rev .= "_{$themesubrevision}"; 921 } 922 923 $url = new moodle_url("/theme/styles.php"); 924 if (!empty($CFG->slasharguments)) { 925 $url->set_slashargument('/'.$this->name.'/'.$rev.'/editor', 'noparam', true); 926 } else { 927 $url->params(array('theme'=>$this->name,'rev'=>$rev, 'type'=>'editor')); 928 } 929 } else { 930 $params = array('theme'=>$this->name, 'type'=>'editor'); 931 $url = new moodle_url('/theme/styles_debug.php', $params); 932 } 933 return $url; 934 } 935 936 /** 937 * Returns the content of the CSS to be used in editor content 938 * 939 * @return array 940 */ 941 public function editor_css_files() { 942 $files = array(); 943 944 // First editor plugins. 945 $plugins = core_component::get_plugin_list('editor'); 946 foreach ($plugins as $plugin => $fulldir) { 947 $sheetfile = "$fulldir/editor_styles.css"; 948 if (is_readable($sheetfile)) { 949 $files['plugin_'.$plugin] = $sheetfile; 950 } 951 952 $subplugintypes = core_component::get_subplugins("editor_{$plugin}"); 953 // Fetch sheets for any editor subplugins. 954 foreach ($subplugintypes as $plugintype => $subplugins) { 955 foreach ($subplugins as $subplugin) { 956 $plugindir = core_component::get_plugin_directory($plugintype, $subplugin); 957 $sheetfile = "{$plugindir}/editor_styles.css"; 958 if (is_readable($sheetfile)) { 959 $files["{$plugintype}_{$subplugin}"] = $sheetfile; 960 } 961 } 962 } 963 } 964 965 // Then parent themes - base first, the immediate parent last. 966 foreach (array_reverse($this->parent_configs) as $parent_config) { 967 if (empty($parent_config->editor_sheets)) { 968 continue; 969 } 970 foreach ($parent_config->editor_sheets as $sheet) { 971 $sheetfile = "$parent_config->dir/style/$sheet.css"; 972 if (is_readable($sheetfile)) { 973 $files['parent_'.$parent_config->name.'_'.$sheet] = $sheetfile; 974 } 975 } 976 } 977 // Finally this theme. 978 if (!empty($this->editor_sheets)) { 979 foreach ($this->editor_sheets as $sheet) { 980 $sheetfile = "$this->dir/style/$sheet.css"; 981 if (is_readable($sheetfile)) { 982 $files['theme_'.$sheet] = $sheetfile; 983 } 984 } 985 } 986 987 return $files; 988 } 989 990 /** 991 * Compiles and returns the content of the SCSS to be used in editor content 992 * 993 * @return string Compiled CSS from the editor SCSS 994 */ 995 public function editor_scss_to_css() { 996 $css = ''; 997 $dir = $this->dir; 998 $filenames = []; 999 1000 // Use editor_scss file(s) provided by this theme if set. 1001 if (!empty($this->editor_scss)) { 1002 $filenames = $this->editor_scss; 1003 } else { 1004 // If no editor_scss set, move up theme hierarchy until one is found (if at all). 1005 // This is so child themes only need to set editor_scss if an override is required. 1006 foreach (array_reverse($this->parent_configs) as $parentconfig) { 1007 if (!empty($parentconfig->editor_scss)) { 1008 $dir = $parentconfig->dir; 1009 $filenames = $parentconfig->editor_scss; 1010 1011 // Config found, stop looking. 1012 break; 1013 } 1014 } 1015 } 1016 1017 if (!empty($filenames)) { 1018 $compiler = new core_scss(); 1019 1020 foreach ($filenames as $filename) { 1021 $compiler->set_file("{$dir}/scss/{$filename}.scss"); 1022 1023 try { 1024 $css .= $compiler->to_css(); 1025 } catch (\Exception $e) { 1026 debugging('Error while compiling editor SCSS: ' . $e->getMessage(), DEBUG_DEVELOPER); 1027 } 1028 } 1029 } 1030 1031 return $css; 1032 } 1033 1034 /** 1035 * Get the stylesheet URL of this theme. 1036 * 1037 * @param moodle_page $page Not used... deprecated? 1038 * @return moodle_url[] 1039 */ 1040 public function css_urls(moodle_page $page) { 1041 global $CFG; 1042 1043 $rev = theme_get_revision(); 1044 1045 $urls = array(); 1046 1047 $svg = $this->use_svg_icons(); 1048 $separate = (core_useragent::is_ie() && !core_useragent::check_ie_version('10')); 1049 1050 if ($rev > -1) { 1051 $filename = right_to_left() ? 'all-rtl' : 'all'; 1052 $url = new moodle_url("/theme/styles.php"); 1053 $themesubrevision = theme_get_sub_revision_for_theme($this->name); 1054 1055 // Provide the sub revision to allow us to invalidate cached theme CSS 1056 // on a per theme basis, rather than globally. 1057 if ($themesubrevision && $themesubrevision > 0) { 1058 $rev .= "_{$themesubrevision}"; 1059 } 1060 1061 if (!empty($CFG->slasharguments)) { 1062 $slashargs = ''; 1063 if (!$svg) { 1064 // We add a simple /_s to the start of the path. 1065 // The underscore is used to ensure that it isn't a valid theme name. 1066 $slashargs .= '/_s'.$slashargs; 1067 } 1068 $slashargs .= '/'.$this->name.'/'.$rev.'/'.$filename; 1069 if ($separate) { 1070 $slashargs .= '/chunk0'; 1071 } 1072 $url->set_slashargument($slashargs, 'noparam', true); 1073 } else { 1074 $params = array('theme' => $this->name, 'rev' => $rev, 'type' => $filename); 1075 if (!$svg) { 1076 // We add an SVG param so that we know not to serve SVG images. 1077 // We do this because all modern browsers support SVG and this param will one day be removed. 1078 $params['svg'] = '0'; 1079 } 1080 if ($separate) { 1081 $params['chunk'] = '0'; 1082 } 1083 $url->params($params); 1084 } 1085 $urls[] = $url; 1086 1087 } else { 1088 $baseurl = new moodle_url('/theme/styles_debug.php'); 1089 1090 $css = $this->get_css_files(true); 1091 if (!$svg) { 1092 // We add an SVG param so that we know not to serve SVG images. 1093 // We do this because all modern browsers support SVG and this param will one day be removed. 1094 $baseurl->param('svg', '0'); 1095 } 1096 if (right_to_left()) { 1097 $baseurl->param('rtl', 1); 1098 } 1099 if ($separate) { 1100 // We might need to chunk long files. 1101 $baseurl->param('chunk', '0'); 1102 } 1103 if (core_useragent::is_ie()) { 1104 // Lalala, IE does not allow more than 31 linked CSS files from main document. 1105 $urls[] = new moodle_url($baseurl, array('theme'=>$this->name, 'type'=>'ie', 'subtype'=>'plugins')); 1106 foreach ($css['parents'] as $parent=>$sheets) { 1107 // We need to serve parents individually otherwise we may easily exceed the style limit IE imposes (4096). 1108 $urls[] = new moodle_url($baseurl, array('theme'=>$this->name,'type'=>'ie', 'subtype'=>'parents', 'sheet'=>$parent)); 1109 } 1110 if ($this->get_scss_property()) { 1111 // No need to define the type as IE here. 1112 $urls[] = new moodle_url($baseurl, array('theme' => $this->name, 'type' => 'scss')); 1113 } 1114 $urls[] = new moodle_url($baseurl, array('theme'=>$this->name, 'type'=>'ie', 'subtype'=>'theme')); 1115 1116 } else { 1117 foreach ($css['plugins'] as $plugin=>$unused) { 1118 $urls[] = new moodle_url($baseurl, array('theme'=>$this->name,'type'=>'plugin', 'subtype'=>$plugin)); 1119 } 1120 foreach ($css['parents'] as $parent=>$sheets) { 1121 foreach ($sheets as $sheet=>$unused2) { 1122 $urls[] = new moodle_url($baseurl, array('theme'=>$this->name,'type'=>'parent', 'subtype'=>$parent, 'sheet'=>$sheet)); 1123 } 1124 } 1125 foreach ($css['theme'] as $sheet => $filename) { 1126 if ($sheet === self::SCSS_KEY) { 1127 // This is the theme SCSS file. 1128 $urls[] = new moodle_url($baseurl, array('theme' => $this->name, 'type' => 'scss')); 1129 } else { 1130 // Sheet first in order to make long urls easier to read. 1131 $urls[] = new moodle_url($baseurl, array('sheet'=>$sheet, 'theme'=>$this->name, 'type'=>'theme')); 1132 } 1133 } 1134 } 1135 } 1136 1137 // Allow themes to change the css url to something like theme/mytheme/mycss.php. 1138 component_callback('theme_' . $this->name, 'alter_css_urls', [&$urls]); 1139 return $urls; 1140 } 1141 1142 /** 1143 * Get the whole css stylesheet for production mode. 1144 * 1145 * NOTE: this method is not expected to be used from any addons. 1146 * 1147 * @return string CSS markup compressed 1148 */ 1149 public function get_css_content() { 1150 1151 $csscontent = ''; 1152 foreach ($this->get_css_files(false) as $type => $value) { 1153 foreach ($value as $identifier => $val) { 1154 if (is_array($val)) { 1155 foreach ($val as $v) { 1156 $csscontent .= file_get_contents($v) . "\n"; 1157 } 1158 } else { 1159 if ($type === 'theme' && $identifier === self::SCSS_KEY) { 1160 // We need the content from SCSS because this is the SCSS file from the theme. 1161 if ($compiled = $this->get_css_content_from_scss(false)) { 1162 $csscontent .= $compiled; 1163 } else { 1164 // The compiler failed so default back to any precompiled css that might 1165 // exist. 1166 $csscontent .= $this->get_precompiled_css_content(); 1167 } 1168 } else { 1169 $csscontent .= file_get_contents($val) . "\n"; 1170 } 1171 } 1172 } 1173 } 1174 $csscontent = $this->post_process($csscontent); 1175 $csscontent = core_minify::css($csscontent); 1176 1177 return $csscontent; 1178 } 1179 /** 1180 * Set post processed CSS content cache. 1181 * 1182 * @param string $csscontent The post processed CSS content. 1183 * @return bool True if the content was successfully cached. 1184 */ 1185 public function set_css_content_cache($csscontent) { 1186 1187 $cache = cache::make('core', 'postprocessedcss'); 1188 $key = $this->get_css_cache_key(); 1189 1190 return $cache->set($key, $csscontent); 1191 } 1192 1193 /** 1194 * Return whether the post processed CSS content has been cached. 1195 * 1196 * @return bool Whether the post-processed CSS is available in the cache. 1197 */ 1198 public function has_css_cached_content() { 1199 1200 $key = $this->get_css_cache_key(); 1201 $cache = cache::make('core', 'postprocessedcss'); 1202 1203 return $cache->has($key); 1204 } 1205 1206 /** 1207 * Return cached post processed CSS content. 1208 * 1209 * @return bool|string The cached css content or false if not found. 1210 */ 1211 public function get_css_cached_content() { 1212 1213 $key = $this->get_css_cache_key(); 1214 $cache = cache::make('core', 'postprocessedcss'); 1215 1216 return $cache->get($key); 1217 } 1218 1219 /** 1220 * Generate the css content cache key. 1221 * 1222 * @return string The post processed css cache key. 1223 */ 1224 public function get_css_cache_key() { 1225 $nosvg = (!$this->use_svg_icons()) ? 'nosvg_' : ''; 1226 $rtlmode = ($this->rtlmode == true) ? 'rtl' : 'ltr'; 1227 1228 return $nosvg . $this->name . '_' . $rtlmode; 1229 } 1230 1231 /** 1232 * Get the theme designer css markup, 1233 * the parameters are coming from css_urls(). 1234 * 1235 * NOTE: this method is not expected to be used from any addons. 1236 * 1237 * @param string $type 1238 * @param string $subtype 1239 * @param string $sheet 1240 * @return string CSS markup 1241 */ 1242 public function get_css_content_debug($type, $subtype, $sheet) { 1243 if ($type === 'scss') { 1244 // The SCSS file of the theme is requested. 1245 $csscontent = $this->get_css_content_from_scss(true); 1246 if ($csscontent !== false) { 1247 return $this->post_process($csscontent); 1248 } 1249 return ''; 1250 } 1251 1252 $cssfiles = array(); 1253 $css = $this->get_css_files(true); 1254 1255 if ($type === 'ie') { 1256 // IE is a sloppy browser with weird limits, sorry. 1257 if ($subtype === 'plugins') { 1258 $cssfiles = $css['plugins']; 1259 1260 } else if ($subtype === 'parents') { 1261 if (empty($sheet)) { 1262 // Do not bother with the empty parent here. 1263 } else { 1264 // Build up the CSS for that parent so we can serve it as one file. 1265 foreach ($css[$subtype][$sheet] as $parent => $css) { 1266 $cssfiles[] = $css; 1267 } 1268 } 1269 } else if ($subtype === 'theme') { 1270 $cssfiles = $css['theme']; 1271 foreach ($cssfiles as $key => $value) { 1272 if (in_array($key, [self::SCSS_KEY])) { 1273 // Remove the SCSS file from the theme CSS files. 1274 // The SCSS files use the type 'scss', not 'ie'. 1275 unset($cssfiles[$key]); 1276 } 1277 } 1278 } 1279 1280 } else if ($type === 'plugin') { 1281 if (isset($css['plugins'][$subtype])) { 1282 $cssfiles[] = $css['plugins'][$subtype]; 1283 } 1284 1285 } else if ($type === 'parent') { 1286 if (isset($css['parents'][$subtype][$sheet])) { 1287 $cssfiles[] = $css['parents'][$subtype][$sheet]; 1288 } 1289 1290 } else if ($type === 'theme') { 1291 if (isset($css['theme'][$sheet])) { 1292 $cssfiles[] = $css['theme'][$sheet]; 1293 } 1294 } 1295 1296 $csscontent = ''; 1297 foreach ($cssfiles as $file) { 1298 $contents = file_get_contents($file); 1299 $contents = $this->post_process($contents); 1300 $comment = "/** Path: $type $subtype $sheet.' **/\n"; 1301 $stats = ''; 1302 $csscontent .= $comment.$stats.$contents."\n\n"; 1303 } 1304 1305 return $csscontent; 1306 } 1307 1308 /** 1309 * Get the whole css stylesheet for editor iframe. 1310 * 1311 * NOTE: this method is not expected to be used from any addons. 1312 * 1313 * @return string CSS markup 1314 */ 1315 public function get_css_content_editor() { 1316 $css = ''; 1317 $cssfiles = $this->editor_css_files(); 1318 1319 // If editor has static CSS, include it. 1320 foreach ($cssfiles as $file) { 1321 $css .= file_get_contents($file)."\n"; 1322 } 1323 1324 // If editor has SCSS, compile and include it. 1325 if (($convertedscss = $this->editor_scss_to_css())) { 1326 $css .= $convertedscss; 1327 } 1328 1329 $output = $this->post_process($css); 1330 1331 return $output; 1332 } 1333 1334 /** 1335 * Returns an array of organised CSS files required for this output. 1336 * 1337 * @param bool $themedesigner 1338 * @return array nested array of file paths 1339 */ 1340 protected function get_css_files($themedesigner) { 1341 global $CFG; 1342 1343 $cache = null; 1344 $cachekey = 'cssfiles'; 1345 if ($themedesigner) { 1346 require_once($CFG->dirroot.'/lib/csslib.php'); 1347 // We need some kind of caching here because otherwise the page navigation becomes 1348 // way too slow in theme designer mode. Feel free to create full cache definition later... 1349 $cache = cache::make_from_params(cache_store::MODE_APPLICATION, 'core', 'themedesigner', array('theme' => $this->name)); 1350 if ($files = $cache->get($cachekey)) { 1351 if ($files['created'] > time() - THEME_DESIGNER_CACHE_LIFETIME) { 1352 unset($files['created']); 1353 return $files; 1354 } 1355 } 1356 } 1357 1358 $cssfiles = array('plugins'=>array(), 'parents'=>array(), 'theme'=>array()); 1359 1360 // Get all plugin sheets. 1361 $excludes = $this->resolve_excludes('plugins_exclude_sheets'); 1362 if ($excludes !== true) { 1363 foreach (core_component::get_plugin_types() as $type=>$unused) { 1364 if ($type === 'theme' || (!empty($excludes[$type]) and $excludes[$type] === true)) { 1365 continue; 1366 } 1367 $plugins = core_component::get_plugin_list($type); 1368 foreach ($plugins as $plugin=>$fulldir) { 1369 if (!empty($excludes[$type]) and is_array($excludes[$type]) 1370 and in_array($plugin, $excludes[$type])) { 1371 continue; 1372 } 1373 1374 // Get the CSS from the plugin. 1375 $sheetfile = "$fulldir/styles.css"; 1376 if (is_readable($sheetfile)) { 1377 $cssfiles['plugins'][$type.'_'.$plugin] = $sheetfile; 1378 } 1379 1380 // Create a list of candidate sheets from parents (direct parent last) and current theme. 1381 $candidates = array(); 1382 foreach (array_reverse($this->parent_configs) as $parent_config) { 1383 $candidates[] = $parent_config->name; 1384 } 1385 $candidates[] = $this->name; 1386 1387 // Add the sheets found. 1388 foreach ($candidates as $candidate) { 1389 $sheetthemefile = "$fulldir/styles_{$candidate}.css"; 1390 if (is_readable($sheetthemefile)) { 1391 $cssfiles['plugins'][$type.'_'.$plugin.'_'.$candidate] = $sheetthemefile; 1392 } 1393 } 1394 } 1395 } 1396 } 1397 1398 // Find out wanted parent sheets. 1399 $excludes = $this->resolve_excludes('parents_exclude_sheets'); 1400 if ($excludes !== true) { 1401 foreach (array_reverse($this->parent_configs) as $parent_config) { // Base first, the immediate parent last. 1402 $parent = $parent_config->name; 1403 if (empty($parent_config->sheets) || (!empty($excludes[$parent]) and $excludes[$parent] === true)) { 1404 continue; 1405 } 1406 foreach ($parent_config->sheets as $sheet) { 1407 if (!empty($excludes[$parent]) && is_array($excludes[$parent]) 1408 && in_array($sheet, $excludes[$parent])) { 1409 continue; 1410 } 1411 1412 // We never refer to the parent LESS files. 1413 $sheetfile = "$parent_config->dir/style/$sheet.css"; 1414 if (is_readable($sheetfile)) { 1415 $cssfiles['parents'][$parent][$sheet] = $sheetfile; 1416 } 1417 } 1418 } 1419 } 1420 1421 1422 // Current theme sheets. 1423 // We first add the SCSS file because we want the CSS ones to 1424 // be included after the SCSS code. 1425 if ($this->get_scss_property()) { 1426 $cssfiles['theme'][self::SCSS_KEY] = true; 1427 } 1428 if (is_array($this->sheets)) { 1429 foreach ($this->sheets as $sheet) { 1430 $sheetfile = "$this->dir/style/$sheet.css"; 1431 if (is_readable($sheetfile) && !isset($cssfiles['theme'][$sheet])) { 1432 $cssfiles['theme'][$sheet] = $sheetfile; 1433 } 1434 } 1435 } 1436 1437 if ($cache) { 1438 $files = $cssfiles; 1439 $files['created'] = time(); 1440 $cache->set($cachekey, $files); 1441 } 1442 return $cssfiles; 1443 } 1444 1445 /** 1446 * Return the CSS content generated from the SCSS file. 1447 * 1448 * @param bool $themedesigner True if theme designer is enabled. 1449 * @return bool|string Return false when the compilation failed. Else the compiled string. 1450 */ 1451 protected function get_css_content_from_scss($themedesigner) { 1452 global $CFG; 1453 1454 list($paths, $scss) = $this->get_scss_property(); 1455 if (!$scss) { 1456 throw new coding_exception('The theme did not define a SCSS file, or it is not readable.'); 1457 } 1458 1459 // We might need more memory/time to do this, so let's play safe. 1460 raise_memory_limit(MEMORY_EXTRA); 1461 core_php_time_limit::raise(300); 1462 1463 // TODO: MDL-62757 When changing anything in this method please do not forget to check 1464 // if the validate() method in class admin_setting_configthemepreset needs updating too. 1465 1466 $cachedir = make_localcache_directory('scsscache-' . $this->name, false); 1467 $cacheoptions = []; 1468 if ($themedesigner) { 1469 $cacheoptions = array( 1470 'cacheDir' => $cachedir, 1471 'prefix' => 'scssphp_', 1472 'forceRefresh' => false, 1473 ); 1474 } else { 1475 if (file_exists($cachedir)) { 1476 remove_dir($cachedir); 1477 } 1478 } 1479 1480 // Set-up the compiler. 1481 $compiler = new core_scss($cacheoptions); 1482 1483 if ($this->supports_source_maps($themedesigner)) { 1484 // Enable source maps. 1485 $compiler->setSourceMapOptions([ 1486 'sourceMapBasepath' => str_replace('\\', '/', $CFG->dirroot), 1487 'sourceMapRootpath' => $CFG->wwwroot . '/' 1488 ]); 1489 $compiler->setSourceMap($compiler::SOURCE_MAP_INLINE); 1490 } 1491 1492 $compiler->prepend_raw_scss($this->get_pre_scss_code()); 1493 if (is_string($scss)) { 1494 $compiler->set_file($scss); 1495 } else { 1496 $compiler->append_raw_scss($scss($this)); 1497 $compiler->setImportPaths($paths); 1498 } 1499 $compiler->append_raw_scss($this->get_extra_scss_code()); 1500 1501 try { 1502 // Compile! 1503 $compiled = $compiler->to_css(); 1504 1505 } catch (\Exception $e) { 1506 $compiled = false; 1507 debugging('Error while compiling SCSS: ' . $e->getMessage(), DEBUG_DEVELOPER); 1508 } 1509 1510 // Try to save memory. 1511 $compiler = null; 1512 unset($compiler); 1513 1514 return $compiled; 1515 } 1516 1517 /** 1518 * Return the precompiled CSS if the precompiledcsscallback exists. 1519 * 1520 * @return string Return compiled css. 1521 */ 1522 public function get_precompiled_css_content() { 1523 $configs = array_reverse($this->parent_configs) + [$this]; 1524 $css = ''; 1525 1526 foreach ($configs as $config) { 1527 if (isset($config->precompiledcsscallback)) { 1528 $function = $config->precompiledcsscallback; 1529 if (function_exists($function)) { 1530 $css .= $function($this); 1531 } 1532 } 1533 } 1534 return $css; 1535 } 1536 1537 /** 1538 * Get the icon system to use. 1539 * 1540 * @return string 1541 */ 1542 public function get_icon_system() { 1543 1544 // Getting all the candidate functions. 1545 $system = false; 1546 if (isset($this->iconsystem) && \core\output\icon_system::is_valid_system($this->iconsystem)) { 1547 return $this->iconsystem; 1548 } 1549 foreach ($this->parent_configs as $parent_config) { 1550 if (isset($parent_config->iconsystem) && \core\output\icon_system::is_valid_system($parent_config->iconsystem)) { 1551 return $parent_config->iconsystem; 1552 } 1553 } 1554 return \core\output\icon_system::STANDARD; 1555 } 1556 1557 /** 1558 * Return extra SCSS code to add when compiling. 1559 * 1560 * This is intended to be used by themes to inject some SCSS code 1561 * before it gets compiled. If you want to inject variables you 1562 * should use {@link self::get_scss_variables()}. 1563 * 1564 * @return string The SCSS code to inject. 1565 */ 1566 public function get_extra_scss_code() { 1567 $content = ''; 1568 1569 // Getting all the candidate functions. 1570 $candidates = array(); 1571 foreach ($this->parent_configs as $parent_config) { 1572 if (!isset($parent_config->extrascsscallback)) { 1573 continue; 1574 } 1575 $candidates[] = $parent_config->extrascsscallback; 1576 } 1577 $candidates[] = $this->extrascsscallback; 1578 1579 // Calling the functions. 1580 foreach ($candidates as $function) { 1581 if (function_exists($function)) { 1582 $content .= "\n/** Extra SCSS from $function **/\n" . $function($this) . "\n"; 1583 } 1584 } 1585 1586 return $content; 1587 } 1588 1589 /** 1590 * SCSS code to prepend when compiling. 1591 * 1592 * This is intended to be used by themes to inject SCSS code before it gets compiled. 1593 * 1594 * @return string The SCSS code to inject. 1595 */ 1596 public function get_pre_scss_code() { 1597 $content = ''; 1598 1599 // Getting all the candidate functions. 1600 $candidates = array(); 1601 foreach ($this->parent_configs as $parent_config) { 1602 if (!isset($parent_config->prescsscallback)) { 1603 continue; 1604 } 1605 $candidates[] = $parent_config->prescsscallback; 1606 } 1607 $candidates[] = $this->prescsscallback; 1608 1609 // Calling the functions. 1610 foreach ($candidates as $function) { 1611 if (function_exists($function)) { 1612 $content .= "\n/** Pre-SCSS from $function **/\n" . $function($this) . "\n"; 1613 } 1614 } 1615 1616 return $content; 1617 } 1618 1619 /** 1620 * Get the SCSS property. 1621 * 1622 * This resolves whether a SCSS file (or content) has to be used when generating 1623 * the stylesheet for the theme. It will look at parents themes and check the 1624 * SCSS properties there. 1625 * 1626 * @return False when SCSS is not used. 1627 * An array with the import paths, and the path to the SCSS file or Closure as second. 1628 */ 1629 public function get_scss_property() { 1630 if ($this->scsscache === null) { 1631 $configs = [$this] + $this->parent_configs; 1632 $scss = null; 1633 1634 foreach ($configs as $config) { 1635 $path = "{$config->dir}/scss"; 1636 1637 // We collect the SCSS property until we've found one. 1638 if (empty($scss) && !empty($config->scss)) { 1639 $candidate = is_string($config->scss) ? "{$path}/{$config->scss}.scss" : $config->scss; 1640 if ($candidate instanceof Closure) { 1641 $scss = $candidate; 1642 } else if (is_string($candidate) && is_readable($candidate)) { 1643 $scss = $candidate; 1644 } 1645 } 1646 1647 // We collect the import paths once we've found a SCSS property. 1648 if ($scss && is_dir($path)) { 1649 $paths[] = $path; 1650 } 1651 1652 } 1653 1654 $this->scsscache = $scss !== null ? [$paths, $scss] : false; 1655 } 1656 1657 return $this->scsscache; 1658 } 1659 1660 /** 1661 * Generate a URL to the file that serves theme JavaScript files. 1662 * 1663 * If we determine that the theme has no relevant files, then we return 1664 * early with a null value. 1665 * 1666 * @param bool $inhead true means head url, false means footer 1667 * @return moodle_url|null 1668 */ 1669 public function javascript_url($inhead) { 1670 global $CFG; 1671 1672 $rev = theme_get_revision(); 1673 $params = array('theme'=>$this->name,'rev'=>$rev); 1674 $params['type'] = $inhead ? 'head' : 'footer'; 1675 1676 // Return early if there are no files to serve 1677 if (count($this->javascript_files($params['type'])) === 0) { 1678 return null; 1679 } 1680 1681 if (!empty($CFG->slasharguments) and $rev > 0) { 1682 $url = new moodle_url("/theme/javascript.php"); 1683 $url->set_slashargument('/'.$this->name.'/'.$rev.'/'.$params['type'], 'noparam', true); 1684 return $url; 1685 } else { 1686 return new moodle_url('/theme/javascript.php', $params); 1687 } 1688 } 1689 1690 /** 1691 * Get the URL's for the JavaScript files used by this theme. 1692 * They won't be served directly, instead they'll be mediated through 1693 * theme/javascript.php. 1694 * 1695 * @param string $type Either javascripts_footer, or javascripts 1696 * @return array 1697 */ 1698 public function javascript_files($type) { 1699 if ($type === 'footer') { 1700 $type = 'javascripts_footer'; 1701 } else { 1702 $type = 'javascripts'; 1703 } 1704 1705 $js = array(); 1706 // find out wanted parent javascripts 1707 $excludes = $this->resolve_excludes('parents_exclude_javascripts'); 1708 if ($excludes !== true) { 1709 foreach (array_reverse($this->parent_configs) as $parent_config) { // base first, the immediate parent last 1710 $parent = $parent_config->name; 1711 if (empty($parent_config->$type)) { 1712 continue; 1713 } 1714 if (!empty($excludes[$parent]) and $excludes[$parent] === true) { 1715 continue; 1716 } 1717 foreach ($parent_config->$type as $javascript) { 1718 if (!empty($excludes[$parent]) and is_array($excludes[$parent]) 1719 and in_array($javascript, $excludes[$parent])) { 1720 continue; 1721 } 1722 $javascriptfile = "$parent_config->dir/javascript/$javascript.js"; 1723 if (is_readable($javascriptfile)) { 1724 $js[] = $javascriptfile; 1725 } 1726 } 1727 } 1728 } 1729 1730 // current theme javascripts 1731 if (is_array($this->$type)) { 1732 foreach ($this->$type as $javascript) { 1733 $javascriptfile = "$this->dir/javascript/$javascript.js"; 1734 if (is_readable($javascriptfile)) { 1735 $js[] = $javascriptfile; 1736 } 1737 } 1738 } 1739 return $js; 1740 } 1741 1742 /** 1743 * Resolves an exclude setting to the themes setting is applicable or the 1744 * setting of its closest parent. 1745 * 1746 * @param string $variable The name of the setting the exclude setting to resolve 1747 * @param string $default 1748 * @return mixed 1749 */ 1750 protected function resolve_excludes($variable, $default = null) { 1751 $setting = $default; 1752 if (is_array($this->{$variable}) or $this->{$variable} === true) { 1753 $setting = $this->{$variable}; 1754 } else { 1755 foreach ($this->parent_configs as $parent_config) { // the immediate parent first, base last 1756 if (!isset($parent_config->{$variable})) { 1757 continue; 1758 } 1759 if (is_array($parent_config->{$variable}) or $parent_config->{$variable} === true) { 1760 $setting = $parent_config->{$variable}; 1761 break; 1762 } 1763 } 1764 } 1765 return $setting; 1766 } 1767 1768 /** 1769 * Returns the content of the one huge javascript file merged from all theme javascript files. 1770 * 1771 * @param bool $type 1772 * @return string 1773 */ 1774 public function javascript_content($type) { 1775 $jsfiles = $this->javascript_files($type); 1776 $js = ''; 1777 foreach ($jsfiles as $jsfile) { 1778 $js .= file_get_contents($jsfile)."\n"; 1779 } 1780 return $js; 1781 } 1782 1783 /** 1784 * Post processes CSS. 1785 * 1786 * This method post processes all of the CSS before it is served for this theme. 1787 * This is done so that things such as image URL's can be swapped in and to 1788 * run any specific CSS post process method the theme has requested. 1789 * This allows themes to use CSS settings. 1790 * 1791 * @param string $css The CSS to process. 1792 * @return string The processed CSS. 1793 */ 1794 public function post_process($css) { 1795 // now resolve all image locations 1796 if (preg_match_all('/\[\[pix:([a-z0-9_]+\|)?([^\]]+)\]\]/', $css, $matches, PREG_SET_ORDER)) { 1797 $replaced = array(); 1798 foreach ($matches as $match) { 1799 if (isset($replaced[$match[0]])) { 1800 continue; 1801 } 1802 $replaced[$match[0]] = true; 1803 $imagename = $match[2]; 1804 $component = rtrim($match[1], '|'); 1805 $imageurl = $this->image_url($imagename, $component)->out(false); 1806 // we do not need full url because the image.php is always in the same dir 1807 $imageurl = preg_replace('|^http.?://[^/]+|', '', $imageurl); 1808 $css = str_replace($match[0], $imageurl, $css); 1809 } 1810 } 1811 1812 // Now resolve all font locations. 1813 if (preg_match_all('/\[\[font:([a-z0-9_]+\|)?([^\]]+)\]\]/', $css, $matches, PREG_SET_ORDER)) { 1814 $replaced = array(); 1815 foreach ($matches as $match) { 1816 if (isset($replaced[$match[0]])) { 1817 continue; 1818 } 1819 $replaced[$match[0]] = true; 1820 $fontname = $match[2]; 1821 $component = rtrim($match[1], '|'); 1822 $fonturl = $this->font_url($fontname, $component)->out(false); 1823 // We do not need full url because the font.php is always in the same dir. 1824 $fonturl = preg_replace('|^http.?://[^/]+|', '', $fonturl); 1825 $css = str_replace($match[0], $fonturl, $css); 1826 } 1827 } 1828 1829 // Now resolve all theme settings or do any other postprocessing. 1830 // This needs to be done before calling core parser, since the parser strips [[settings]] tags. 1831 $csspostprocess = $this->csspostprocess; 1832 if (function_exists($csspostprocess)) { 1833 $css = $csspostprocess($css, $this); 1834 } 1835 1836 // Post processing using an object representation of CSS. 1837 $treeprocessor = $this->get_css_tree_post_processor(); 1838 $needsparsing = !empty($treeprocessor) || !empty($this->rtlmode); 1839 if ($needsparsing) { 1840 1841 // We might need more memory/time to do this, so let's play safe. 1842 raise_memory_limit(MEMORY_EXTRA); 1843 core_php_time_limit::raise(300); 1844 1845 $parser = new core_cssparser($css); 1846 $csstree = $parser->parse(); 1847 unset($parser); 1848 1849 if ($this->rtlmode) { 1850 $this->rtlize($csstree); 1851 } 1852 1853 if ($treeprocessor) { 1854 $treeprocessor($csstree, $this); 1855 } 1856 1857 $css = $csstree->render(); 1858 unset($csstree); 1859 } 1860 1861 return $css; 1862 } 1863 1864 /** 1865 * Flip a stylesheet to RTL. 1866 * 1867 * @param Object $csstree The parsed CSS tree structure to flip. 1868 * @return void 1869 */ 1870 protected function rtlize($csstree) { 1871 $rtlcss = new core_rtlcss($csstree); 1872 $rtlcss->flip(); 1873 } 1874 1875 /** 1876 * Return the direct URL for an image from the pix folder. 1877 * 1878 * Use this function sparingly and never for icons. For icons use pix_icon or the pix helper in a mustache template. 1879 * 1880 * @deprecated since Moodle 3.3 1881 * @param string $imagename the name of the icon. 1882 * @param string $component specification of one plugin like in get_string() 1883 * @return moodle_url 1884 */ 1885 public function pix_url($imagename, $component) { 1886 debugging('pix_url is deprecated. Use image_url for images and pix_icon for icons.', DEBUG_DEVELOPER); 1887 return $this->image_url($imagename, $component); 1888 } 1889 1890 /** 1891 * Return the direct URL for an image from the pix folder. 1892 * 1893 * Use this function sparingly and never for icons. For icons use pix_icon or the pix helper in a mustache template. 1894 * 1895 * @param string $imagename the name of the icon. 1896 * @param string $component specification of one plugin like in get_string() 1897 * @return moodle_url 1898 */ 1899 public function image_url($imagename, $component) { 1900 global $CFG; 1901 1902 $params = array('theme'=>$this->name); 1903 $svg = $this->use_svg_icons(); 1904 1905 if (empty($component) or $component === 'moodle' or $component === 'core') { 1906 $params['component'] = 'core'; 1907 } else { 1908 $params['component'] = $component; 1909 } 1910 1911 $rev = theme_get_revision(); 1912 if ($rev != -1) { 1913 $params['rev'] = $rev; 1914 } 1915 1916 $params['image'] = $imagename; 1917 1918 $url = new moodle_url("/theme/image.php"); 1919 if (!empty($CFG->slasharguments) and $rev > 0) { 1920 $path = '/'.$params['theme'].'/'.$params['component'].'/'.$params['rev'].'/'.$params['image']; 1921 if (!$svg) { 1922 // We add a simple /_s to the start of the path. 1923 // The underscore is used to ensure that it isn't a valid theme name. 1924 $path = '/_s'.$path; 1925 } 1926 $url->set_slashargument($path, 'noparam', true); 1927 } else { 1928 if (!$svg) { 1929 // We add an SVG param so that we know not to serve SVG images. 1930 // We do this because all modern browsers support SVG and this param will one day be removed. 1931 $params['svg'] = '0'; 1932 } 1933 $url->params($params); 1934 } 1935 1936 return $url; 1937 } 1938 1939 /** 1940 * Return the URL for a font 1941 * 1942 * @param string $font the name of the font (including extension). 1943 * @param string $component specification of one plugin like in get_string() 1944 * @return moodle_url 1945 */ 1946 public function font_url($font, $component) { 1947 global $CFG; 1948 1949 $params = array('theme'=>$this->name); 1950 1951 if (empty($component) or $component === 'moodle' or $component === 'core') { 1952 $params['component'] = 'core'; 1953 } else { 1954 $params['component'] = $component; 1955 } 1956 1957 $rev = theme_get_revision(); 1958 if ($rev != -1) { 1959 $params['rev'] = $rev; 1960 } 1961 1962 $params['font'] = $font; 1963 1964 $url = new moodle_url("/theme/font.php"); 1965 if (!empty($CFG->slasharguments) and $rev > 0) { 1966 $path = '/'.$params['theme'].'/'.$params['component'].'/'.$params['rev'].'/'.$params['font']; 1967 $url->set_slashargument($path, 'noparam', true); 1968 } else { 1969 $url->params($params); 1970 } 1971 1972 return $url; 1973 } 1974 1975 /** 1976 * Returns URL to the stored file via pluginfile.php. 1977 * 1978 * Note the theme must also implement pluginfile.php handler, 1979 * theme revision is used instead of the itemid. 1980 * 1981 * @param string $setting 1982 * @param string $filearea 1983 * @return string protocol relative URL or null if not present 1984 */ 1985 public function setting_file_url($setting, $filearea) { 1986 global $CFG; 1987 1988 if (empty($this->settings->$setting)) { 1989 return null; 1990 } 1991 1992 $component = 'theme_'.$this->name; 1993 $itemid = theme_get_revision(); 1994 $filepath = $this->settings->$setting; 1995 $syscontext = context_system::instance(); 1996 1997 $url = moodle_url::make_file_url("$CFG->wwwroot/pluginfile.php", "/$syscontext->id/$component/$filearea/$itemid".$filepath); 1998 1999 // Now this is tricky because the we can not hardcode http or https here, lets use the relative link. 2000 // Note: unfortunately moodle_url does not support //urls yet. 2001 2002 $url = preg_replace('|^https?://|i', '//', $url->out(false)); 2003 2004 return $url; 2005 } 2006 2007 /** 2008 * Serve the theme setting file. 2009 * 2010 * @param string $filearea 2011 * @param array $args 2012 * @param bool $forcedownload 2013 * @param array $options 2014 * @return bool may terminate if file not found or donotdie not specified 2015 */ 2016 public function setting_file_serve($filearea, $args, $forcedownload, $options) { 2017 global $CFG; 2018 require_once("$CFG->libdir/filelib.php"); 2019 2020 $syscontext = context_system::instance(); 2021 $component = 'theme_'.$this->name; 2022 2023 $revision = array_shift($args); 2024 if ($revision < 0) { 2025 $lifetime = 0; 2026 } else { 2027 $lifetime = 60*60*24*60; 2028 // By default, theme files must be cache-able by both browsers and proxies. 2029 if (!array_key_exists('cacheability', $options)) { 2030 $options['cacheability'] = 'public'; 2031 } 2032 } 2033 2034 $fs = get_file_storage(); 2035 $relativepath = implode('/', $args); 2036 2037 $fullpath = "/{$syscontext->id}/{$component}/{$filearea}/0/{$relativepath}"; 2038 $fullpath = rtrim($fullpath, '/'); 2039 if ($file = $fs->get_file_by_hash(sha1($fullpath))) { 2040 send_stored_file($file, $lifetime, 0, $forcedownload, $options); 2041 return true; 2042 } else { 2043 send_file_not_found(); 2044 } 2045 } 2046 2047 /** 2048 * Resolves the real image location. 2049 * 2050 * $svg was introduced as an arg in 2.4. It is important because not all supported browsers support the use of SVG 2051 * and we need a way in which to turn it off. 2052 * By default SVG won't be used unless asked for. This is done for two reasons: 2053 * 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 2054 * browser supports SVG. 2055 * 2. We only serve SVG images from locations we trust. This must NOT include any areas where the image may have been uploaded 2056 * by the user due to security concerns. 2057 * 2058 * @param string $image name of image, may contain relative path 2059 * @param string $component 2060 * @param bool $svg|null Should SVG images also be looked for? If null, resorts to $CFG->svgicons if that is set; falls back to 2061 * auto-detection of browser support otherwise 2062 * @return string full file path 2063 */ 2064 public function resolve_image_location($image, $component, $svg = false) { 2065 global $CFG; 2066 2067 if (!is_bool($svg)) { 2068 // If $svg isn't a bool then we need to decide for ourselves. 2069 $svg = $this->use_svg_icons(); 2070 } 2071 2072 if ($component === 'moodle' or $component === 'core' or empty($component)) { 2073 if ($imagefile = $this->image_exists("$this->dir/pix_core/$image", $svg)) { 2074 return $imagefile; 2075 } 2076 foreach (array_reverse($this->parent_configs) as $parent_config) { // base first, the immediate parent last 2077 if ($imagefile = $this->image_exists("$parent_config->dir/pix_core/$image", $svg)) { 2078 return $imagefile; 2079 } 2080 } 2081 if ($imagefile = $this->image_exists("$CFG->dataroot/pix/$image", $svg)) { 2082 return $imagefile; 2083 } 2084 if ($imagefile = $this->image_exists("$CFG->dirroot/pix/$image", $svg)) { 2085 return $imagefile; 2086 } 2087 return null; 2088 2089 } else if ($component === 'theme') { //exception 2090 if ($image === 'favicon') { 2091 return "$this->dir/pix/favicon.ico"; 2092 } 2093 if ($imagefile = $this->image_exists("$this->dir/pix/$image", $svg)) { 2094 return $imagefile; 2095 } 2096 foreach (array_reverse($this->parent_configs) as $parent_config) { // base first, the immediate parent last 2097 if ($imagefile = $this->image_exists("$parent_config->dir/pix/$image", $svg)) { 2098 return $imagefile; 2099 } 2100 } 2101 return null; 2102 2103 } else { 2104 if (strpos($component, '_') === false) { 2105 $component = 'mod_'.$component; 2106 } 2107 list($type, $plugin) = explode('_', $component, 2); 2108 2109 if ($imagefile = $this->image_exists("$this->dir/pix_plugins/$type/$plugin/$image", $svg)) { 2110 return $imagefile; 2111 } 2112 foreach (array_reverse($this->parent_configs) as $parent_config) { // base first, the immediate parent last 2113 if ($imagefile = $this->image_exists("$parent_config->dir/pix_plugins/$type/$plugin/$image", $svg)) { 2114 return $imagefile; 2115 } 2116 } 2117 if ($imagefile = $this->image_exists("$CFG->dataroot/pix_plugins/$type/$plugin/$image", $svg)) { 2118 return $imagefile; 2119 } 2120 $dir = core_component::get_plugin_directory($type, $plugin); 2121 if ($imagefile = $this->image_exists("$dir/pix/$image", $svg)) { 2122 return $imagefile; 2123 } 2124 return null; 2125 } 2126 } 2127 2128 /** 2129 * Resolves the real font location. 2130 * 2131 * @param string $font name of font file 2132 * @param string $component 2133 * @return string full file path 2134 */ 2135 public function resolve_font_location($font, $component) { 2136 global $CFG; 2137 2138 if ($component === 'moodle' or $component === 'core' or empty($component)) { 2139 if (file_exists("$this->dir/fonts_core/$font")) { 2140 return "$this->dir/fonts_core/$font"; 2141 } 2142 foreach (array_reverse($this->parent_configs) as $parent_config) { // Base first, the immediate parent last. 2143 if (file_exists("$parent_config->dir/fonts_core/$font")) { 2144 return "$parent_config->dir/fonts_core/$font"; 2145 } 2146 } 2147 if (file_exists("$CFG->dataroot/fonts/$font")) { 2148 return "$CFG->dataroot/fonts/$font"; 2149 } 2150 if (file_exists("$CFG->dirroot/lib/fonts/$font")) { 2151 return "$CFG->dirroot/lib/fonts/$font"; 2152 } 2153 return null; 2154 2155 } else if ($component === 'theme') { // Exception. 2156 if (file_exists("$this->dir/fonts/$font")) { 2157 return "$this->dir/fonts/$font"; 2158 } 2159 foreach (array_reverse($this->parent_configs) as $parent_config) { // Base first, the immediate parent last. 2160 if (file_exists("$parent_config->dir/fonts/$font")) { 2161 return "$parent_config->dir/fonts/$font"; 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 if (file_exists("$this->dir/fonts_plugins/$type/$plugin/$font")) { 2173 return "$this->dir/fonts_plugins/$type/$plugin/$font"; 2174 } 2175 foreach (array_reverse($this->parent_configs) as $parent_config) { // Base first, the immediate parent last. 2176 if (file_exists("$parent_config->dir/fonts_plugins/$type/$plugin/$font")) { 2177 return "$parent_config->dir/fonts_plugins/$type/$plugin/$font"; 2178 } 2179 } 2180 if (file_exists("$CFG->dataroot/fonts_plugins/$type/$plugin/$font")) { 2181 return "$CFG->dataroot/fonts_plugins/$type/$plugin/$font"; 2182 } 2183 $dir = core_component::get_plugin_directory($type, $plugin); 2184 if (file_exists("$dir/fonts/$font")) { 2185 return "$dir/fonts/$font"; 2186 } 2187 return null; 2188 } 2189 } 2190 2191 /** 2192 * Return true if we should look for SVG images as well. 2193 * 2194 * @return bool 2195 */ 2196 public function use_svg_icons() { 2197 global $CFG; 2198 if ($this->usesvg === null) { 2199 2200 if (!isset($CFG->svgicons)) { 2201 $this->usesvg = core_useragent::supports_svg(); 2202 } else { 2203 // Force them on/off depending upon the setting. 2204 $this->usesvg = (bool)$CFG->svgicons; 2205 } 2206 } 2207 return $this->usesvg; 2208 } 2209 2210 /** 2211 * Forces the usesvg setting to either true or false, avoiding any decision making. 2212 * 2213 * This function should only ever be used when absolutely required, and before any generation of image URL's has occurred. 2214 * DO NOT ABUSE THIS FUNCTION... not that you'd want to right ;) 2215 * 2216 * @param bool $setting True to force the use of svg when available, null otherwise. 2217 */ 2218 public function force_svg_use($setting) { 2219 $this->usesvg = (bool)$setting; 2220 } 2221 2222 /** 2223 * Set to be in RTL mode. 2224 * 2225 * This will likely be used when post processing the CSS before serving it. 2226 * 2227 * @param bool $inrtl True when in RTL mode. 2228 */ 2229 public function set_rtl_mode($inrtl = true) { 2230 $this->rtlmode = $inrtl; 2231 } 2232 2233 /** 2234 * Checks if source maps are supported 2235 * 2236 * @param bool $themedesigner True if theme designer is enabled. 2237 * @return boolean True if source maps are supported. 2238 */ 2239 public function supports_source_maps($themedesigner): bool { 2240 if (empty($this->rtlmode) && $themedesigner) { 2241 return true; 2242 } 2243 return false; 2244 } 2245 2246 /** 2247 * Whether the theme is being served in RTL mode. 2248 * 2249 * @return bool True when in RTL mode. 2250 */ 2251 public function get_rtl_mode() { 2252 return $this->rtlmode; 2253 } 2254 2255 /** 2256 * Checks if file with any image extension exists. 2257 * 2258 * The order to these images was adjusted prior to the release of 2.4 2259 * At that point the were the following image counts in Moodle core: 2260 * 2261 * - png = 667 in pix dirs (1499 total) 2262 * - gif = 385 in pix dirs (606 total) 2263 * - jpg = 62 in pix dirs (74 total) 2264 * - jpeg = 0 in pix dirs (1 total) 2265 * 2266 * There is work in progress to move towards SVG presently hence that has been prioritiesed. 2267 * 2268 * @param string $filepath 2269 * @param bool $svg If set to true SVG images will also be looked for. 2270 * @return string image name with extension 2271 */ 2272 private static function image_exists($filepath, $svg = false) { 2273 if ($svg && file_exists("$filepath.svg")) { 2274 return "$filepath.svg"; 2275 } else if (file_exists("$filepath.png")) { 2276 return "$filepath.png"; 2277 } else if (file_exists("$filepath.gif")) { 2278 return "$filepath.gif"; 2279 } else if (file_exists("$filepath.jpg")) { 2280 return "$filepath.jpg"; 2281 } else if (file_exists("$filepath.jpeg")) { 2282 return "$filepath.jpeg"; 2283 } else { 2284 return false; 2285 } 2286 } 2287 2288 /** 2289 * Loads the theme config from config.php file. 2290 * 2291 * @param string $themename 2292 * @param stdClass $settings from config_plugins table 2293 * @param boolean $parentscheck true to also check the parents. . 2294 * @return stdClass The theme configuration 2295 */ 2296 private static function find_theme_config($themename, $settings, $parentscheck = true) { 2297 // We have to use the variable name $THEME (upper case) because that 2298 // is what is used in theme config.php files. 2299 2300 if (!$dir = theme_config::find_theme_location($themename)) { 2301 return null; 2302 } 2303 2304 $THEME = new stdClass(); 2305 $THEME->name = $themename; 2306 $THEME->dir = $dir; 2307 $THEME->settings = $settings; 2308 2309 global $CFG; // just in case somebody tries to use $CFG in theme config 2310 include("$THEME->dir/config.php"); 2311 2312 // verify the theme configuration is OK 2313 if (!is_array($THEME->parents)) { 2314 // parents option is mandatory now 2315 return null; 2316 } else { 2317 // We use $parentscheck to only check the direct parents (avoid infinite loop). 2318 if ($parentscheck) { 2319 // Find all parent theme configs. 2320 foreach ($THEME->parents as $parent) { 2321 $parentconfig = theme_config::find_theme_config($parent, $settings, false); 2322 if (empty($parentconfig)) { 2323 return null; 2324 } 2325 } 2326 } 2327 } 2328 2329 return $THEME; 2330 } 2331 2332 /** 2333 * Finds the theme location and verifies the theme has all needed files 2334 * and is not obsoleted. 2335 * 2336 * @param string $themename 2337 * @return string full dir path or null if not found 2338 */ 2339 private static function find_theme_location($themename) { 2340 global $CFG; 2341 2342 if (file_exists("$CFG->dirroot/theme/$themename/config.php")) { 2343 $dir = "$CFG->dirroot/theme/$themename"; 2344 2345 } else if (!empty($CFG->themedir) and file_exists("$CFG->themedir/$themename/config.php")) { 2346 $dir = "$CFG->themedir/$themename"; 2347 2348 } else { 2349 return null; 2350 } 2351 2352 if (file_exists("$dir/styles.php")) { 2353 //legacy theme - needs to be upgraded - upgrade info is displayed on the admin settings page 2354 return null; 2355 } 2356 2357 return $dir; 2358 } 2359 2360 /** 2361 * Get the renderer for a part of Moodle for this theme. 2362 * 2363 * @param moodle_page $page the page we are rendering 2364 * @param string $component the name of part of moodle. E.g. 'core', 'quiz', 'qtype_multichoice'. 2365 * @param string $subtype optional subtype such as 'news' resulting to 'mod_forum_news' 2366 * @param string $target one of rendering target constants 2367 * @return renderer_base the requested renderer. 2368 */ 2369 public function get_renderer(moodle_page $page, $component, $subtype = null, $target = null) { 2370 if (is_null($this->rf)) { 2371 $classname = $this->rendererfactory; 2372 $this->rf = new $classname($this); 2373 } 2374 2375 return $this->rf->get_renderer($page, $component, $subtype, $target); 2376 } 2377 2378 /** 2379 * Get the information from {@link $layouts} for this type of page. 2380 * 2381 * @param string $pagelayout the the page layout name. 2382 * @return array the appropriate part of {@link $layouts}. 2383 */ 2384 protected function layout_info_for_page($pagelayout) { 2385 if (array_key_exists($pagelayout, $this->layouts)) { 2386 return $this->layouts[$pagelayout]; 2387 } else { 2388 debugging('Invalid page layout specified: ' . $pagelayout); 2389 return $this->layouts['standard']; 2390 } 2391 } 2392 2393 /** 2394 * Given the settings of this theme, and the page pagelayout, return the 2395 * full path of the page layout file to use. 2396 * 2397 * Used by {@link core_renderer::header()}. 2398 * 2399 * @param string $pagelayout the the page layout name. 2400 * @return string Full path to the lyout file to use 2401 */ 2402 public function layout_file($pagelayout) { 2403 global $CFG; 2404 2405 $layoutinfo = $this->layout_info_for_page($pagelayout); 2406 $layoutfile = $layoutinfo['file']; 2407 2408 if (array_key_exists('theme', $layoutinfo)) { 2409 $themes = array($layoutinfo['theme']); 2410 } else { 2411 $themes = array_merge(array($this->name),$this->parents); 2412 } 2413 2414 foreach ($themes as $theme) { 2415 if ($dir = $this->find_theme_location($theme)) { 2416 $path = "$dir/layout/$layoutfile"; 2417 2418 // Check the template exists, return general base theme template if not. 2419 if (is_readable($path)) { 2420 return $path; 2421 } 2422 } 2423 } 2424 2425 debugging('Can not find layout file for: ' . $pagelayout); 2426 // fallback to standard normal layout 2427 return "$CFG->dirroot/theme/base/layout/general.php"; 2428 } 2429 2430 /** 2431 * Returns auxiliary page layout options specified in layout configuration array. 2432 * 2433 * @param string $pagelayout 2434 * @return array 2435 */ 2436 public function pagelayout_options($pagelayout) { 2437 $info = $this->layout_info_for_page($pagelayout); 2438 if (!empty($info['options'])) { 2439 return $info['options']; 2440 } 2441 return array(); 2442 } 2443 2444 /** 2445 * Inform a block_manager about the block regions this theme wants on this 2446 * page layout. 2447 * 2448 * @param string $pagelayout the general type of the page. 2449 * @param block_manager $blockmanager the block_manger to set up. 2450 */ 2451 public function setup_blocks($pagelayout, $blockmanager) { 2452 $layoutinfo = $this->layout_info_for_page($pagelayout); 2453 if (!empty($layoutinfo['regions'])) { 2454 $blockmanager->add_regions($layoutinfo['regions'], false); 2455 $blockmanager->set_default_region($layoutinfo['defaultregion']); 2456 } 2457 } 2458 2459 /** 2460 * Gets the visible name for the requested block region. 2461 * 2462 * @param string $region The region name to get 2463 * @param string $theme The theme the region belongs to (may come from the parent theme) 2464 * @return string 2465 */ 2466 protected function get_region_name($region, $theme) { 2467 2468 $stringman = get_string_manager(); 2469 2470 // Check if the name is defined in the theme. 2471 if ($stringman->string_exists('region-' . $region, 'theme_' . $theme)) { 2472 return get_string('region-' . $region, 'theme_' . $theme); 2473 } 2474 2475 // Check the theme parents. 2476 foreach ($this->parents as $parentthemename) { 2477 if ($stringman->string_exists('region-' . $region, 'theme_' . $parentthemename)) { 2478 return get_string('region-' . $region, 'theme_' . $parentthemename); 2479 } 2480 } 2481 2482 // Last resort, try the boost theme for names. 2483 return get_string('region-' . $region, 'theme_boost'); 2484 } 2485 2486 /** 2487 * Get the list of all block regions known to this theme in all templates. 2488 * 2489 * @return array internal region name => human readable name. 2490 */ 2491 public function get_all_block_regions() { 2492 $regions = array(); 2493 foreach ($this->layouts as $layoutinfo) { 2494 foreach ($layoutinfo['regions'] as $region) { 2495 $regions[$region] = $this->get_region_name($region, $this->name); 2496 } 2497 } 2498 return $regions; 2499 } 2500 2501 /** 2502 * Returns the human readable name of the theme 2503 * 2504 * @return string 2505 */ 2506 public function get_theme_name() { 2507 return get_string('pluginname', 'theme_'.$this->name); 2508 } 2509 2510 /** 2511 * Returns the block render method. 2512 * 2513 * It is set by the theme via: 2514 * $THEME->blockrendermethod = '...'; 2515 * 2516 * It can be one of two values, blocks or blocks_for_region. 2517 * It should be set to the method being used by the theme layouts. 2518 * 2519 * @return string 2520 */ 2521 public function get_block_render_method() { 2522 if ($this->blockrendermethod) { 2523 // Return the specified block render method. 2524 return $this->blockrendermethod; 2525 } 2526 // Its not explicitly set, check the parent theme configs. 2527 foreach ($this->parent_configs as $config) { 2528 if (isset($config->blockrendermethod)) { 2529 return $config->blockrendermethod; 2530 } 2531 } 2532 // Default it to blocks. 2533 return 'blocks'; 2534 } 2535 2536 /** 2537 * Get the callable for CSS tree post processing. 2538 * 2539 * @return string|null 2540 */ 2541 public function get_css_tree_post_processor() { 2542 $configs = [$this] + $this->parent_configs; 2543 foreach ($configs as $config) { 2544 if (!empty($config->csstreepostprocessor) && is_callable($config->csstreepostprocessor)) { 2545 return $config->csstreepostprocessor; 2546 } 2547 } 2548 return null; 2549 } 2550 2551 } 2552 2553 /** 2554 * This class keeps track of which HTML tags are currently open. 2555 * 2556 * This makes it much easier to always generate well formed XHTML output, even 2557 * if execution terminates abruptly. Any time you output some opening HTML 2558 * without the matching closing HTML, you should push the necessary close tags 2559 * onto the stack. 2560 * 2561 * @copyright 2009 Tim Hunt 2562 * @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later 2563 * @since Moodle 2.0 2564 * @package core 2565 * @category output 2566 */ 2567 class xhtml_container_stack { 2568 2569 /** 2570 * @var array Stores the list of open containers. 2571 */ 2572 protected $opencontainers = array(); 2573 2574 /** 2575 * @var array In developer debug mode, stores a stack trace of all opens and 2576 * closes, so we can output helpful error messages when there is a mismatch. 2577 */ 2578 protected $log = array(); 2579 2580 /** 2581 * @var boolean Store whether we are developer debug mode. We need this in 2582 * several places including in the destructor where we may not have access to $CFG. 2583 */ 2584 protected $isdebugging; 2585 2586 /** 2587 * Constructor 2588 */ 2589 public function __construct() { 2590 global $CFG; 2591 $this->isdebugging = $CFG->debugdeveloper; 2592 } 2593 2594 /** 2595 * Push the close HTML for a recently opened container onto the stack. 2596 * 2597 * @param string $type The type of container. This is checked when {@link pop()} 2598 * is called and must match, otherwise a developer debug warning is output. 2599 * @param string $closehtml The HTML required to close the container. 2600 */ 2601 public function push($type, $closehtml) { 2602 $container = new stdClass; 2603 $container->type = $type; 2604 $container->closehtml = $closehtml; 2605 if ($this->isdebugging) { 2606 $this->log('Open', $type); 2607 } 2608 array_push($this->opencontainers, $container); 2609 } 2610 2611 /** 2612 * Pop the HTML for the next closing container from the stack. The $type 2613 * must match the type passed when the container was opened, otherwise a 2614 * warning will be output. 2615 * 2616 * @param string $type The type of container. 2617 * @return string the HTML required to close the container. 2618 */ 2619 public function pop($type) { 2620 if (empty($this->opencontainers)) { 2621 debugging('<p>There are no more open containers. This suggests there is a nesting problem.</p>' . 2622 $this->output_log(), DEBUG_DEVELOPER); 2623 return; 2624 } 2625 2626 $container = array_pop($this->opencontainers); 2627 if ($container->type != $type) { 2628 debugging('<p>The type of container to be closed (' . $container->type . 2629 ') does not match the type of the next open container (' . $type . 2630 '). This suggests there is a nesting problem.</p>' . 2631 $this->output_log(), DEBUG_DEVELOPER); 2632 } 2633 if ($this->isdebugging) { 2634 $this->log('Close', $type); 2635 } 2636 return $container->closehtml; 2637 } 2638 2639 /** 2640 * Close all but the last open container. This is useful in places like error 2641 * handling, where you want to close all the open containers (apart from <body>) 2642 * before outputting the error message. 2643 * 2644 * @param bool $shouldbenone assert that the stack should be empty now - causes a 2645 * developer debug warning if it isn't. 2646 * @return string the HTML required to close any open containers inside <body>. 2647 */ 2648 public function pop_all_but_last($shouldbenone = false) { 2649 if ($shouldbenone && count($this->opencontainers) != 1) { 2650 debugging('<p>Some HTML tags were opened in the body of the page but not closed.</p>' . 2651 $this->output_log(), DEBUG_DEVELOPER); 2652 } 2653 $output = ''; 2654 while (count($this->opencontainers) > 1) { 2655 $container = array_pop($this->opencontainers); 2656 $output .= $container->closehtml; 2657 } 2658 return $output; 2659 } 2660 2661 /** 2662 * You can call this function if you want to throw away an instance of this 2663 * class without properly emptying the stack (for example, in a unit test). 2664 * Calling this method stops the destruct method from outputting a developer 2665 * debug warning. After calling this method, the instance can no longer be used. 2666 */ 2667 public function discard() { 2668 $this->opencontainers = null; 2669 } 2670 2671 /** 2672 * Adds an entry to the log. 2673 * 2674 * @param string $action The name of the action 2675 * @param string $type The type of action 2676 */ 2677 protected function log($action, $type) { 2678 $this->log[] = '<li>' . $action . ' ' . $type . ' at:' . 2679 format_backtrace(debug_backtrace()) . '</li>'; 2680 } 2681 2682 /** 2683 * Outputs the log's contents as a HTML list. 2684 * 2685 * @return string HTML list of the log 2686 */ 2687 protected function output_log() { 2688 return '<ul>' . implode("\n", $this->log) . '</ul>'; 2689 } 2690 }
title
Description
Body
title
Description
Body
title
Description
Body
title
Body
