theme.inc 83.9 KB
Newer Older
Dries's avatar
 
Dries committed
1
<?php
2

3
/**
Dries's avatar
 
Dries committed
4
 * @file
5
 * The theme system, which controls the output of Drupal.
Dries's avatar
 
Dries committed
6 7 8 9
 *
 * The theme system allows for nearly all output of the Drupal system to be
 * customized by user themes.
 */
Dries's avatar
 
Dries committed
10

11
use Drupal\Component\Serialization\Json;
12
use Drupal\Component\Utility\SafeMarkup;
13
use Drupal\Component\Utility\String;
14
use Drupal\Component\Utility\UrlHelper;
15
use Drupal\Component\Utility\Xss;
16
use Drupal\Core\Config\Config;
17
use Drupal\Core\Config\StorageException;
18
use Drupal\Core\Extension\Extension;
19
use Drupal\Core\Extension\ExtensionNameLengthException;
20 21
use Drupal\Core\Page\LinkElement;
use Drupal\Core\Page\MetaElement;
22
use Drupal\Core\Template\Attribute;
23
use Drupal\Core\Theme\ThemeSettings;
24
use Drupal\Component\Utility\NestedArray;
25
use Drupal\Core\Render\Element;
26
use Symfony\Component\HttpFoundation\Request;
27

28
/**
29
 * @defgroup content_flags Content markers
30
 * @{
31 32 33 34
 * Markers used by mark.html.twig and node_mark() to designate content.
 *
 * @see mark.html.twig
 * @see node_mark()
35
 */
36 37 38 39

/**
 * Mark content as read.
 */
40
const MARK_READ = 0;
41 42 43 44

/**
 * Mark content as being new.
 */
45
const MARK_NEW = 1;
46 47 48 49

/**
 * Mark content as being updated.
 */
50
const MARK_UPDATED = 2;
51

52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67
/**
 * A responsive table class; hide table cell on narrow devices.
 *
 * Indicates that a column has medium priority and thus can be hidden on narrow
 * width devices and shown on medium+ width devices (i.e. tablets and desktops).
 */
const RESPONSIVE_PRIORITY_MEDIUM = 'priority-medium';

/**
 * A responsive table class; only show table cell on wide devices.
 *
 * Indicates that a column has low priority and thus can be hidden on narrow
 * and medium viewports and shown on wide devices (i.e. desktops).
 */
const RESPONSIVE_PRIORITY_LOW = 'priority-low';

68
/**
69
 * @} End of "defgroup content_flags".
70 71
 */

72 73 74
/**
 * Determines if a theme is available to use.
 *
75
 * @param string|\Drupal\Core\Extension\Extension $theme
76 77
 *   Either the name of a theme or a full theme object.
 *
78
 * @return bool
79
 *   Boolean TRUE if the theme is installed or is the site administration theme;
80
 *   FALSE otherwise.
81
 *
82 83 84 85
 * @deprecated in Drupal 8.x-dev, will be removed before Drupal 8.0.
 *   Use \Drupal::service('access_check.theme')->checkAccess().
 *
 * @see \Drupal\Core\Theme\ThemeAccessCheck::checkAccess().
86 87
 */
function drupal_theme_access($theme) {
88
  if ($theme instanceof Extension) {
89
    $theme = $theme->getName();
90
  }
91
  return \Drupal::service('access_check.theme')->checkAccess($theme);
92 93
}

94
/**
95
 * Gets the theme registry.
96
 *
97
 * @param bool $complete
98
 *   Optional boolean to indicate whether to return the complete theme registry
99 100 101 102 103 104 105
 *   array or an instance of the Drupal\Core\Utility\ThemeRegistry class.
 *   If TRUE, the complete theme registry array will be returned. This is useful
 *   if you want to foreach over the whole registry, use array_* functions or
 *   inspect it in a debugger. If FALSE, an instance of the
 *   Drupal\Core\Utility\ThemeRegistry class will be returned, this provides an
 *   ArrayObject which allows it to be accessed with array syntax and isset(),
 *   and should be more lightweight than the full registry. Defaults to TRUE.
106
 *
107
 * @return
108 109
 *   The complete theme registry array, or an instance of the
 *   Drupal\Core\Utility\ThemeRegistry class.
110
 */
111
function theme_get_registry($complete = TRUE) {
112
  $theme_registry = \Drupal::service('theme.registry');
113
  if ($complete) {
114
    return $theme_registry->get();
115 116
  }
  else {
117
    return $theme_registry->getRuntime();
118 119 120 121
  }
}

/**
122 123 124 125
 * Forces the system to rebuild the theme registry.
 *
 * This function should be called when modules are added to the system, or when
 * a dynamic system needs to add more theme hooks.
126
 */
127
function drupal_theme_rebuild() {
128
  \Drupal::service('theme.registry')->reset();
129 130
}

Dries's avatar
 
Dries committed
131
/**
132
 * Returns a list of all currently available themes.
Dries's avatar
 
Dries committed
133
 *
134 135
 * Retrieved from the database, if available and the site is not in maintenance
 * mode; otherwise compiled freshly from the filesystem.
136
 *
Dries's avatar
 
Dries committed
137
 * @param $refresh
138
 *   Whether to reload the list of themes from the database. Defaults to FALSE.
139
 *
140 141
 * @return array
 *   An associative array of the currently available themes.
142
 *
143 144 145 146
 * @deprecated in Drupal 8.x-dev, will be removed before Drupal 8.0.
 *   Use \Drupal::service('theme_handler')->listInfo().
 *
 * @see \Drupal\Core\Extension\ThemeHandler::listInfo().
147
 */
148
function list_themes($refresh = FALSE) {
149 150
  /** @var \Drupal\Core\Extension\ThemeHandler $theme_handler */
  $theme_handler = \Drupal::service('theme_handler');
Dries's avatar
 
Dries committed
151 152

  if ($refresh) {
153
    $theme_handler->reset();
154
    system_list_reset();
Dries's avatar
 
Dries committed
155 156
  }

157
  return $theme_handler->listInfo();
Dries's avatar
 
Dries committed
158 159
}

Dries's avatar
 
Dries committed
160
/**
161
 * Generates themed output (internal use only).
162
 *
163 164 165 166 167 168 169 170
 * _theme() is an internal function. Do not call this function directly as it
 * will prevent the following items from working correctly:
 * - Render caching.
 * - JavaScript and CSS asset attachment.
 * - Pre / post render hooks.
 * - Defaults provided by hook_element_info(), including attached assets.
 * Instead, build a render array with a #theme key, and either return the
 * array (where possible) or call drupal_render() to convert it to HTML.
171
 *
172 173 174 175 176 177
 * All requests for themed output must go through this function, which is
 * invoked as part of the @link theme_render drupal_render() process @endlink.
 * The appropriate theme function is indicated by the #theme property
 * of a renderable array. _theme() examines the request and routes it to the
 * appropriate @link themeable theme function or template @endlink, by checking
 * the theme registry.
178
 *
179
 * @param $hook
180 181
 *   The name of the theme hook to call. If the name contains a
 *   double-underscore ('__') and there isn't an implementation for the full
182
 *   name, the part before the '__' is checked. This allows a fallback to a
183
 *   more generic implementation. For example, if _theme('links__node', ...) is
184 185
 *   called, but there is no implementation of that theme hook, then the
 *   'links' implementation is used. This process is iterative, so if
186
 *   _theme('links__contextual__node', ...) is called, _theme() checks for the
187 188 189 190 191 192
 *   following implementations, and uses the first one that exists:
 *   - links__contextual__node
 *   - links__contextual
 *   - links
 *   This allows themes to create specific theme implementations for named
 *   objects and contexts of otherwise generic theme hooks. The $hook parameter
193
 *   may also be an array, in which case the first theme hook that has an
194
 *   implementation is used. This allows for the code that calls _theme() to
195
 *   explicitly specify the fallback order in a situation where using the '__'
196
 *   convention is not desired or is insufficient.
197 198
 * @param $variables
 *   An associative array of variables to merge with defaults from the theme
199 200 201 202
 *   registry, pass to preprocess functions for modification, and finally, pass
 *   to the function or template implementing the theme hook. Alternatively,
 *   this can be a renderable array, in which case, its properties are mapped to
 *   variables expected by the theme hook implementations.
203
 *
204 205 206
 * @return string|false
 *   An HTML string representing the themed output or FALSE if the passed $hook
 *   is not implemented.
207
 *
208
 * @see drupal_render()
209
 * @see themeable
210 211
 * @see hook_theme()
 * @see template_preprocess()
Dries's avatar
 
Dries committed
212
 */
213
function _theme($hook, $variables = array()) {
214
  static $default_attributes;
215 216

  $module_handler = \Drupal::moduleHandler();
217
  $active_theme = \Drupal::theme()->getActiveTheme();
218

219 220
  // If called before all modules are loaded, we do not necessarily have a full
  // theme registry to work with, and therefore cannot process the theme
221
  // request properly. See also \Drupal\Core\Theme\Registry::get().
222
  if (!$module_handler->isLoaded() && !defined('MAINTENANCE_MODE')) {
223
    throw new Exception(t('_theme() may not be called until all modules are loaded.'));
224 225
  }

226 227
  /** @var \Drupal\Core\Utility\ThemeRegistry $theme_registry */
  $theme_registry = \Drupal::service('theme.registry')->getRuntime();
228

229 230
  // If an array of hook candidates were passed, use the first one that has an
  // implementation.
231 232
  if (is_array($hook)) {
    foreach ($hook as $candidate) {
233
      if ($theme_registry->has($candidate)) {
234 235 236 237 238
        break;
      }
    }
    $hook = $candidate;
  }
239 240 241
  // Save the original theme hook, so it can be supplied to theme variable
  // preprocess callbacks.
  $original_hook = $hook;
242

243 244
  // If there's no implementation, check for more generic fallbacks. If there's
  // still no implementation, log an error and return an empty string.
245
  if (!$theme_registry->has($hook)) {
246 247 248 249
    // Iteratively strip everything after the last '__' delimiter, until an
    // implementation is found.
    while ($pos = strrpos($hook, '__')) {
      $hook = substr($hook, 0, $pos);
250
      if ($theme_registry->has($hook)) {
251 252 253
        break;
      }
    }
254
    if (!$theme_registry->has($hook)) {
255 256 257
      // Only log a message when not trying theme suggestions ($hook being an
      // array).
      if (!isset($candidate)) {
258
        \Drupal::logger('theme')->warning('Theme hook %hook not found.', array('%hook' => $hook));
259
      }
260
      // There is no theme implementation for the hook passed. Return FALSE so
261
      // the function calling _theme() can differentiate between a hook that
262 263
      // exists and renders an empty string and a hook that is not implemented.
      return FALSE;
264
    }
265 266
  }

267
  $info = $theme_registry->get($hook);
268 269

  // If a renderable array is passed as $variables, then set $variables to
270
  // the arguments expected by the theme function.
271 272 273
  if (isset($variables['#theme']) || isset($variables['#theme_wrappers'])) {
    $element = $variables;
    $variables = array();
274 275
    if (isset($info['variables'])) {
      foreach (array_keys($info['variables']) as $name) {
276
        if (isset($element["#$name"]) || array_key_exists("#$name", $element)) {
277 278
          $variables[$name] = $element["#$name"];
        }
279 280
      }
    }
281 282
    else {
      $variables[$info['render element']] = $element;
283 284
      // Give a hint to render engines to prevent infinite recursion.
      $variables[$info['render element']]['#render_children'] = TRUE;
285
    }
286
  }
287

288
  // Merge in argument defaults.
289 290 291 292 293
  if (!empty($info['variables'])) {
    $variables += $info['variables'];
  }
  elseif (!empty($info['render element'])) {
    $variables += array($info['render element'] => array());
294
  }
295 296 297 298
  // Supply original caller info.
  $variables += array(
    'theme_hook_original' => $original_hook,
  );
299

300 301 302 303 304 305 306 307 308 309 310 311
  // Set base hook for later use. For example if '#theme' => 'node__article'
  // is called, we run hook_theme_suggestions_node_alter() rather than
  // hook_theme_suggestions_node__article_alter(), and also pass in the base
  // hook as the last parameter to the suggestions alter hooks.
  if (isset($info['base hook'])) {
    $base_theme_hook = $info['base hook'];
  }
  else {
    $base_theme_hook = $hook;
  }

  // Invoke hook_theme_suggestions_HOOK().
312
  $suggestions = $module_handler->invokeAll('theme_suggestions_' . $base_theme_hook, array($variables));
313
  // If _theme() was invoked with a direct theme suggestion like
314 315 316 317 318
  // '#theme' => 'node__article', add it to the suggestions array before
  // invoking suggestion alter hooks.
  if (isset($info['base hook'])) {
    $suggestions[] = $hook;
  }
319 320 321 322 323 324 325

  // Invoke hook_theme_suggestions_alter() and
  // hook_theme_suggestions_HOOK_alter().
  $hooks = array(
    'theme_suggestions',
    'theme_suggestions_' . $base_theme_hook,
  );
326
  $module_handler->alter($hooks, $suggestions, $variables, $base_theme_hook);
327
  \Drupal::theme()->alter($hooks, $suggestions, $variables, $base_theme_hook);
328 329

  // Check if each suggestion exists in the theme registry, and if so,
330 331
  // use it instead of the hook that _theme() was called with. For example, a
  // function may call _theme('node', ...), but a module can add
332 333 334
  // 'node__article' as a suggestion via hook_theme_suggestions_HOOK_alter(),
  // enabling a theme to have an alternate template file for article nodes.
  foreach (array_reverse($suggestions) as $suggestion) {
335 336
    if ($theme_registry->has($suggestion)) {
      $info = $theme_registry->get($suggestion);
337 338 339 340
      break;
    }
  }

341 342 343 344 345 346 347 348
  // Include a file if the theme function or variable preprocessor is held
  // elsewhere.
  if (!empty($info['includes'])) {
    foreach ($info['includes'] as $include_file) {
      include_once DRUPAL_ROOT . '/' . $include_file;
    }
  }

349
  // Invoke the variable preprocessors, if any.
350 351
  if (isset($info['base hook'])) {
    $base_hook = $info['base hook'];
352
    $base_hook_info = $theme_registry->get($base_hook);
353
    // Include files required by the base hook, since its variable preprocessors
354 355 356 357 358 359
    // might reside there.
    if (!empty($base_hook_info['includes'])) {
      foreach ($base_hook_info['includes'] as $include_file) {
        include_once DRUPAL_ROOT . '/' . $include_file;
      }
    }
360
    // Replace the preprocess functions with those from the base hook.
361
    if (isset($base_hook_info['preprocess functions'])) {
362 363 364 365
      // Set a variable for the 'theme_hook_suggestion'. This is used to
      // maintain backwards compatibility with template engines.
      $theme_hook_suggestion = $hook;
      $info['preprocess functions'] = $base_hook_info['preprocess functions'];
366 367
    }
  }
368 369 370 371
  if (isset($info['preprocess functions'])) {
    foreach ($info['preprocess functions'] as $preprocessor_function) {
      if (function_exists($preprocessor_function)) {
        $preprocessor_function($variables, $hook, $info);
372
      }
373
    }
374 375 376 377 378 379 380 381 382
    // Allow theme preprocess functions to set $variables['#attached'] and use
    // it like the #attached property on render arrays. In Drupal 8, this is the
    // (only) officially supported method of attaching assets from preprocess
    // functions. Assets attached here should be associated with the template
    // that we're preprocessing variables for.
    if (isset($variables['#attached'])) {
      $preprocess_attached = ['#attached' => $variables['#attached']];
      drupal_render($preprocess_attached, TRUE);
    }
383
  }
384

385
  // Generate the output using either a function or a template.
386
  $output = '';
387
  if (isset($info['function'])) {
388
    if (function_exists($info['function'])) {
389
      $output = SafeMarkup::set($info['function']($variables));
Dries's avatar
 
Dries committed
390
    }
Dries's avatar
 
Dries committed
391
  }
392
  else {
393 394
    $render_function = 'twig_render_template';
    $extension = '.html.twig';
395

396
    // The theme engine may use a different extension and a different renderer.
397
    $theme_engine = $active_theme->getEngine();
398
    if (isset($theme_engine)) {
399
      if ($info['type'] != 'module') {
400 401
        if (function_exists($theme_engine . '_render_template')) {
          $render_function = $theme_engine . '_render_template';
402
        }
403
        $extension_function = $theme_engine . '_extension';
404 405 406 407 408 409
        if (function_exists($extension_function)) {
          $extension = $extension_function();
        }
      }
    }

410 411 412 413 414
    // In some cases, a template implementation may not have had
    // template_preprocess() run (for example, if the default implementation is
    // a function, but a template overrides that default implementation). In
    // these cases, a template should still be able to expect to have access to
    // the variables provided by template_preprocess(), so we add them here if
415 416 417 418 419
    // they don't already exist. We don't want the overhead of running
    // template_preprocess() twice, so we use the 'directory' variable to
    // determine if it has already run, which while not completely intuitive,
    // is reasonably safe, and allows us to save on the overhead of adding some
    // new variable to track that.
420 421
    if (!isset($variables['directory'])) {
      $default_template_variables = array();
422
      template_preprocess($default_template_variables, $hook, $info);
423 424
      $variables += $default_template_variables;
    }
425 426 427 428 429 430 431 432 433 434 435 436 437 438
    if (!isset($default_attributes)) {
      $default_attributes = new Attribute();
    }
    foreach (array('attributes', 'title_attributes', 'content_attributes') as $key) {
      if (isset($variables[$key]) && !($variables[$key] instanceof Attribute)) {
        if ($variables[$key]) {
          $variables[$key] = new Attribute($variables[$key]);
        }
        else {
          // Create empty attributes.
          $variables[$key] = clone $default_attributes;
        }
      }
    }
439

440 441 442 443
    // Render the output using the template file.
    $template_file = $info['template'] . $extension;
    if (isset($info['path'])) {
      $template_file = $info['path'] . '/' . $template_file;
444
    }
445 446 447 448 449
    // Add the theme suggestions to the variables array just before rendering
    // the template for backwards compatibility with template engines.
    $variables['theme_hook_suggestions'] = $suggestions;
    // For backwards compatibility, pass 'theme_hook_suggestion' on to the
    // template engine. This is only set when calling a direct suggestion like
450
    // '#theme' => 'menu__shortcut_default' when the template exists in the
451 452 453 454
    // current theme.
    if (isset($theme_hook_suggestion)) {
      $variables['theme_hook_suggestion'] = $theme_hook_suggestion;
    }
455
    $output = $render_function($template_file, $variables);
Dries's avatar
 
Dries committed
456
  }
457

458
  return (string) $output;
459 460
}

461
/**
462
 * Allows themes and/or theme engines to discover overridden theme functions.
463 464 465 466 467 468
 *
 * @param $cache
 *   The existing cache of theme hooks to test against.
 * @param $prefixes
 *   An array of prefixes to test, in reverse order of importance.
 *
469
 * @return $implementations
470 471 472
 *   The functions found, suitable for returning from hook_theme;
 */
function drupal_find_theme_functions($cache, $prefixes) {
473
  $implementations = array();
474 475 476 477
  $functions = get_defined_functions();

  foreach ($cache as $hook => $info) {
    foreach ($prefixes as $prefix) {
478 479 480 481 482 483
      // Find theme functions that implement possible "suggestion" variants of
      // registered theme hooks and add those as new registered theme hooks.
      // The 'pattern' key defines a common prefix that all suggestions must
      // start with. The default is the name of the hook followed by '__'. An
      // 'base hook' key is added to each entry made for a found suggestion,
      // so that common functionality can be implemented for all suggestions of
484
      // the same base hook. To keep things simple, deep hierarchy of
485 486 487 488
      // suggestions is not supported: each suggestion's 'base hook' key
      // refers to a base hook, not to another suggestion, and all suggestions
      // are found using the base hook's pattern, not a pattern from an
      // intermediary suggestion.
489
      $pattern = isset($info['pattern']) ? $info['pattern'] : ($hook . '__');
490
      if (!isset($info['base hook']) && !empty($pattern)) {
491
        $matches = preg_grep('/^' . $prefix . '_' . $pattern . '/', $functions['user']);
492 493
        if ($matches) {
          foreach ($matches as $match) {
494
            $new_hook = substr($match, strlen($prefix) + 1);
495
            $arg_name = isset($info['variables']) ? 'variables' : 'render element';
496
            $implementations[$new_hook] = array(
497
              'function' => $match,
498
              $arg_name => $info[$arg_name],
499
              'base hook' => $hook,
500 501 502 503
            );
          }
        }
      }
504 505 506
      // Find theme functions that implement registered theme hooks and include
      // that in what is returned so that the registry knows that the theme has
      // this implementation.
507
      if (function_exists($prefix . '_' . $hook)) {
508
        $implementations[$hook] = array(
509
          'function' => $prefix . '_' . $hook,
510 511 512 513 514
        );
      }
    }
  }

515
  return $implementations;
516 517 518
}

/**
519
 * Allows themes and/or theme engines to easily discover overridden templates.
520 521 522 523 524 525 526 527 528
 *
 * @param $cache
 *   The existing cache of theme hooks to test against.
 * @param $extension
 *   The extension that these templates will have.
 * @param $path
 *   The path to search.
 */
function drupal_find_theme_templates($cache, $extension, $path) {
529
  $implementations = array();
530

531 532 533 534
  // Collect paths to all sub-themes grouped by base themes. These will be
  // used for filtering. This allows base themes to have sub-themes in its
  // folder hierarchy without affecting the base themes template discovery.
  $theme_paths = array();
535
  foreach (list_themes() as $theme_info) {
536
    if (!empty($theme_info->base_theme)) {
537
      $theme_paths[$theme_info->base_theme][$theme_info->getName()] = $theme_info->getPath();
538 539 540 541 542 543 544
    }
  }
  foreach ($theme_paths as $basetheme => $subthemes) {
    foreach ($subthemes as $subtheme => $subtheme_path) {
      if (isset($theme_paths[$subtheme])) {
        $theme_paths[$basetheme] = array_merge($theme_paths[$basetheme], $theme_paths[$subtheme]);
      }
545 546
    }
  }
547
  $theme = \Drupal::theme()->getActiveTheme()->getName();
548
  $subtheme_paths = isset($theme_paths[$theme]) ? $theme_paths[$theme] : array();
549

550
  // Escape the periods in the extension.
551
  $regex = '/' . str_replace('.', '\.', $extension) . '$/';
552
  // Get a listing of all template files in the path to search.
553
  $files = file_scan_directory($path, $regex, array('key' => 'filename'));
554 555 556 557

  // Find templates that implement registered theme hooks and include that in
  // what is returned so that the registry knows that the theme has this
  // implementation.
558
  foreach ($files as $template => $file) {
559
    // Ignore sub-theme templates for the current theme.
560
    if (strpos($file->uri, str_replace($subtheme_paths, '', $file->uri)) !== 0) {
561 562
      continue;
    }
563 564
    // Remove the extension from the filename.
    $template = str_replace($extension, '', $template);
565 566 567 568
    // Transform - in filenames to _ to match function naming scheme
    // for the purposes of searching.
    $hook = strtr($template, '-', '_');
    if (isset($cache[$hook])) {
569
      $implementations[$hook] = array(
570
        'template' => $template,
571
        'path' => dirname($file->uri),
572 573
      );
    }
574 575 576 577

    // Match templates based on the 'template' filename.
    foreach ($cache as $hook => $info) {
      if (isset($info['template'])) {
578
        $template_candidates = array($info['template'], str_replace($info['theme path'] . '/templates/', '', $info['template']));
579 580 581 582 583 584 585 586
        if (in_array($template, $template_candidates)) {
          $implementations[$hook] = array(
            'template' => $template,
            'path' => dirname($file->uri),
          );
        }
      }
    }
587 588
  }

589
  // Find templates that implement possible "suggestion" variants of registered
590
  // theme hooks and add those as new registered theme hooks. See
591 592
  // drupal_find_theme_functions() for more information about suggestions and
  // the use of 'pattern' and 'base hook'.
593 594
  $patterns = array_keys($files);
  foreach ($cache as $hook => $info) {
595
    $pattern = isset($info['pattern']) ? $info['pattern'] : ($hook . '__');
596
    if (!isset($info['base hook']) && !empty($pattern)) {
597 598
      // Transform _ in pattern to - to match file naming scheme
      // for the purposes of searching.
599
      $pattern = strtr($pattern, '_', '-');
600

601
      $matches = preg_grep('/^' . $pattern . '/', $patterns);
602 603
      if ($matches) {
        foreach ($matches as $match) {
604
          $file = $match;
605 606
          // Remove the extension from the filename.
          $file = str_replace($extension, '', $file);
607 608
          // Put the underscores back in for the hook name and register this
          // pattern.
609
          $arg_name = isset($info['variables']) ? 'variables' : 'render element';
610
          $implementations[strtr($file, '-', '_')] = array(
611
            'template' => $file,
612
            'path' => dirname($files[$match]->uri),
613
            $arg_name => $info[$arg_name],
614
            'base hook' => $hook,
615 616 617 618 619
          );
        }
      }
    }
  }
620
  return $implementations;
621 622
}

Dries's avatar
 
Dries committed
623
/**
624
 * Retrieves a setting for the current theme or for a given theme.
Dries's avatar
 
Dries committed
625
 *
626 627
 * The final setting is obtained from the last value found in the following
 * sources:
628 629 630
 * - the default theme-specific settings defined in any base theme's .info.yml
 *   file
 * - the default theme-specific settings defined in the theme's .info.yml file
631 632 633 634
 * - the saved values from the global theme settings form
 * - the saved values from the theme's settings form
 * To only retrieve the default global theme setting, an empty string should be
 * given for $theme.
Dries's avatar
 
Dries committed
635 636
 *
 * @param $setting_name
637
 *   The name of the setting to be retrieved.
638
 * @param $theme
639 640
 *   The name of a given theme; defaults to the current theme.
 *
Dries's avatar
 
Dries committed
641 642 643
 * @return
 *   The value of the requested setting, NULL if the setting does not exist.
 */
644 645
function theme_get_setting($setting_name, $theme = NULL) {
  $cache = &drupal_static(__FUNCTION__, array());
Dries's avatar
 
Dries committed
646

647
  // If no key is given, use the current theme if we can determine it.
648
  if (!isset($theme)) {
649
    $theme = \Drupal::theme()->getActiveTheme()->getName();
650
  }
Dries's avatar
 
Dries committed
651

652
  if (empty($cache[$theme])) {
653 654
    // Create a theme settings object.
    $cache[$theme] = new ThemeSettings($theme);
655

656 657
    // Get the values for the theme-specific settings from the .info.yml files
    // of the theme and all its base themes.
658 659
    $themes = list_themes();
    if ($theme && isset($themes[$theme])) {
660 661 662 663 664 665
      $theme_object = $themes[$theme];

      // Create a list which includes the current theme and all its base themes.
      if (isset($theme_object->base_themes)) {
        $theme_keys = array_keys($theme_object->base_themes);
        $theme_keys[] = $theme;
Dries's avatar
 
Dries committed
666
      }
667 668 669
      else {
        $theme_keys = array($theme);
      }
670
      // Read hard-coded default settings from the theme info files.
671 672
      foreach ($theme_keys as $theme_key) {
        if (!empty($themes[$theme_key]->info['settings'])) {
673
          $cache[$theme]->merge($themes[$theme_key]->info['settings']);
674
        }
Dries's avatar
 
Dries committed
675 676 677
      }
    }

678
    // Get the global settings from configuration.
679
    $cache[$theme]->merge(\Drupal::config('system.theme.global')->get());
680

681
    if ($theme && isset($themes[$theme])) {
682 683 684 685 686 687 688 689
      // Retrieve configured theme-specific settings, if any.
      try {
        if ($theme_settings = \Drupal::config($theme . '.settings')->get()) {
          $cache[$theme]->merge($theme_settings);
        }
      }
      catch (StorageException $e) {
      }
690

691 692 693
      // If the theme does not support a particular feature, override the global
      // setting and set the value to NULL.
      if (!empty($theme_object->info['features'])) {
694
        foreach (_system_default_theme_features() as $feature) {
695
          if (!in_array($feature, $theme_object->info['features'])) {
696
            $cache[$theme]->set('features.' . $feature, NULL);
697 698 699 700
          }
        }
      }

701
      // Generate the path to the logo image.
702 703 704
      if ($cache[$theme]->get('features.logo')) {
        $logo_path = $cache[$theme]->get('logo.path');
        if ($cache[$theme]->get('logo.use_default')) {
705
          $cache[$theme]->set('logo.url', file_create_url($theme_object->getPath() . '/logo.png'));
706
        }
707 708
        elseif ($logo_path) {
          $cache[$theme]->set('logo.url', file_create_url($logo_path));
709 710
        }
      }
711 712

      // Generate the path to the favicon.
713 714 715
      if ($cache[$theme]->get('features.favicon')) {
        $favicon_path = $cache[$theme]->get('favicon.path');
        if ($cache[$theme]->get('favicon.use_default')) {
716
          if (file_exists($favicon = $theme_object->getPath() . '/favicon.ico')) {
717
            $cache[$theme]->set('favicon.url', file_create_url($favicon));
718 719
          }
          else {
720
            $cache[$theme]->set('favicon.url', file_create_url('core/misc/favicon.ico'));
721 722
          }
        }
723 724
        elseif ($favicon_path) {
          $cache[$theme]->set('favicon.url', file_create_url($favicon_path));
725 726
        }
        else {
727
          $cache[$theme]->set('features.favicon', FALSE);
728
        }
729
      }
730
    }
Dries's avatar
 
Dries committed
731 732
  }

733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773
  return $cache[$theme]->get($setting_name);
}

/**
 * Converts theme settings to configuration.
 *
 * @see system_theme_settings_submit()
 *
 * @param array $theme_settings
 *   An array of theme settings from system setting form or a Drupal 7 variable.
 * @param Config $config
 *   The configuration object to update.
 *
 * @return
 *   The Config object with updated data.
 */
function theme_settings_convert_to_config(array $theme_settings, Config $config) {
  foreach ($theme_settings as $key => $value) {
    if ($key == 'default_logo') {
      $config->set('logo.use_default', $value);
    }
    else if ($key == 'logo_path') {
      $config->set('logo.path', $value);
    }
    else if ($key == 'default_favicon') {
      $config->set('favicon.use_default', $value);
    }
    else if ($key == 'favicon_path') {
      $config->set('favicon.path', $value);
    }
    else if ($key == 'favicon_mimetype') {
      $config->set('favicon.mimetype', $value);
    }
    else if (substr($key, 0, 7) == 'toggle_') {
      $config->set('features.' . drupal_substr($key, 7), $value);
    }
    else if (!in_array($key, array('theme', 'logo_upload'))) {
      $config->set($key, $value);
    }
  }
  return $config;
Dries's avatar
 
Dries committed
774 775
}

776
/**
777
 * @addtogroup themeable
778 779
 * @{
 */
780

781
/**
782 783 784
 * Prepares variables for time templates.
 *
 * Default template: time.html.twig.
785 786
 *
 * @param array $variables
787
 *   An associative array possibly containing:
788 789 790
 *   - attributes['timestamp']:
 *   - timestamp:
 *   - text:
791
 */
792
function template_preprocess_time(&$variables) {
793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813
  // Format the 'datetime' attribute based on the timestamp.
  // @see http://www.w3.org/TR/html5-author/the-time-element.html#attr-time-datetime
  if (!isset($variables['attributes']['datetime']) && isset($variables['timestamp'])) {
    $variables['attributes']['datetime'] = format_date($variables['timestamp'], 'html_datetime', '', 'UTC');
  }

  // If no text was provided, try to auto-generate it.
  if (!isset($variables['text'])) {
    // Format and use a human-readable version of the timestamp, if any.
    if (isset($variables['timestamp'])) {
      $variables['text'] = format_date($variables['timestamp']);
      $variables['html'] = FALSE;
    }
    // Otherwise, use the literal datetime attribute.
    elseif (isset($variables['attributes']['datetime'])) {
      $variables['text'] = $variables['attributes']['datetime'];
      $variables['html'] = FALSE;
    }
  }
}

814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864
/**
 * Prepares variables for datetime form element templates.
 *
 * The datetime form element serves as a wrapper around the date element type,
 * which creates a date and a time component for a date.
 *
 * Default template: datetime-form.html.twig.
 *
 * @param array $variables
 *   An associative array containing:
 *   - element: An associative array containing the properties of the element.
 *     Properties used: #title, #value, #options, #description, #required,
 *     #attributes.
 *
 * @see form_process_datetime()
 */
function template_preprocess_datetime_form(&$variables) {
  $element = $variables['element'];

  $variables['attributes'] = array();
  if (isset($element['#id'])) {
    $variables['attributes']['id'] = $element['#id'];
  }
  if