theme.inc 95.7 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\Utility\String;
12
use Drupal\Component\Utility\UrlHelper;
13
use Drupal\Component\Utility\Xss;
14
use Drupal\Core\Config\Config;
15
use Drupal\Core\Config\StorageException;
16
use Drupal\Core\Language\Language;
17
use Drupal\Core\Extension\Extension;
18
use Drupal\Core\Extension\ExtensionNameLengthException;
19
use Drupal\Core\Template\Attribute;
20
use Drupal\Core\Template\RenderWrapper;
21
use Drupal\Core\Theme\ThemeSettings;
22
use Drupal\Component\Utility\NestedArray;
23
use Drupal\Core\Render\Element;
24

25
/**
26
 * @defgroup content_flags Content markers
27
28
29
30
 * @{
 * Markers used by theme_mark() and node_mark() to designate content.
 * @see theme_mark(), node_mark()
 */
31
32
33
34

/**
 * Mark content as read.
 */
35
const MARK_READ = 0;
36
37
38
39

/**
 * Mark content as being new.
 */
40
const MARK_NEW = 1;
41
42
43
44

/**
 * Mark content as being updated.
 */
45
const MARK_UPDATED = 2;
46

47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
/**
 * 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';

63
/**
64
 * @} End of "defgroup content_flags".
65
66
 */

67
68
69
/**
 * Determines if a theme is available to use.
 *
70
 * @param string|\Drupal\Core\Extension\Extension $theme
71
72
 *   Either the name of a theme or a full theme object.
 *
73
 * @return bool
74
75
 *   Boolean TRUE if the theme is enabled or is the site administration theme;
 *   FALSE otherwise.
76
 *
77
78
79
80
 * @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().
81
82
 */
function drupal_theme_access($theme) {
83
  if ($theme instanceof Extension) {
84
    $theme = $theme->getName();
85
  }
86
  return \Drupal::service('access_check.theme')->checkAccess($theme);
87
88
}

Dries's avatar
   
Dries committed
89
/**
90
 * Initializes the theme system by loading the theme.
Dries's avatar
   
Dries committed
91
 */
92
function drupal_theme_initialize() {
93
  global $theme, $theme_key;
94
95
96
97
98

  // If $theme is already set, assume the others are set, too, and do nothing
  if (isset($theme)) {
    return;
  }
Dries's avatar
   
Dries committed
99

100
  $themes = list_themes();
Dries's avatar
   
Dries committed
101

102
103
104
105
  // @todo Let the theme.negotiator listen to the kernel request event.
  // Determine the active theme for the theme negotiator service. This includes
  // the default theme as well as really specific ones like the ajax base theme.
  $request = \Drupal::request();
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
  $theme = \Drupal::service('theme.negotiator')->determineActiveTheme($request);

  // If no theme could be negotiated, or if the negotiated theme is not within
  // the list of enabled themes, fall back to the default theme output of core
  // and modules (similar to Stark, but without a theme extension at all). This
  // is possible, because _drupal_theme_initialize() always loads the Twig theme
  // engine.
  if (!$theme || !isset($themes[$theme])) {
    $theme = 'core';
    $theme_key = $theme;
    // /core/core.info.yml does not actually exist, but is required because
    // Extension expects a pathname.
    _drupal_theme_initialize(new Extension('theme', 'core/core.info.yml'));
    return;
  }
Dries's avatar
   
Dries committed
121
122
123
124

  // Store the identifier for retrieving theme settings with.
  $theme_key = $theme;

125
126
127
128
  // Find all our ancestor themes and put them in an array.
  $base_theme = array();
  $ancestor = $theme;
  while ($ancestor && isset($themes[$ancestor]->base_theme)) {
129
    $ancestor = $themes[$ancestor]->base_theme;
130
    $base_theme[] = $themes[$ancestor];
131
  }
132
  _drupal_theme_initialize($themes[$theme], array_reverse($base_theme));
133
134
135
}

/**
136
137
138
 * Initializes the theme system given already loaded information.
 *
 * This function is useful to initialize a theme when no database is present.
139
 *
140
141
142
 * @param \Drupal\Core\Extension\Extension $theme
 *   The theme extension object.
 * @param \Drupal\Core\Extension\Extension[] $base_theme
143
144
145
146
147
148
 *    An optional array of objects that represent the 'base theme' if the
 *    theme is meant to be derivative of another theme. It requires
 *    the same information as the $theme object. It should be in
 *    'oldest first' order, meaning the top level of the chain will
 *    be first.
 */
149
function _drupal_theme_initialize($theme, $base_theme = array()) {
150
151
152
153
  global $theme_info, $base_theme_info, $theme_engine, $theme_path;
  $theme_info = $theme;
  $base_theme_info = $base_theme;

154
  $theme_path = $theme->getPath();
155

156
157
158
159
  // Prepare stylesheets from this theme as well as all ancestor themes.
  // We work it this way so that we can have child themes override parent
  // theme stylesheets easily.
  $final_stylesheets = array();
160
161
162
163
  // CSS file basenames to override, pointing to the final, overridden filepath.
  $theme->stylesheets_override = array();
  // CSS file basenames to remove.
  $theme->stylesheets_remove = array();
164
165
166
167
168
169
170
171
172
173

  // Grab stylesheets from base theme
  foreach ($base_theme as $base) {
    if (!empty($base->stylesheets)) {
      foreach ($base->stylesheets as $media => $stylesheets) {
        foreach ($stylesheets as $name => $stylesheet) {
          $final_stylesheets[$media][$name] = $stylesheet;
        }
      }
    }
174
    $base_theme_path = $base->getPath();
175
176
177
178
179
180
181
182
183
184
185
    if (!empty($base->info['stylesheets-remove'])) {
      foreach ($base->info['stylesheets-remove'] as $basename) {
        $theme->stylesheets_remove[$basename] = $base_theme_path . '/' . $basename;
      }
    }
    if (!empty($base->info['stylesheets-override'])) {
      foreach ($base->info['stylesheets-override'] as $name) {
        $basename = drupal_basename($name);
        $theme->stylesheets_override[$basename] = $base_theme_path . '/' . $name;
      }
    }
186
187
  }

188
189
190
  // Add stylesheets used by this theme.
  if (!empty($theme->stylesheets)) {
    foreach ($theme->stylesheets as $media => $stylesheets) {
191
192
193
194
195
      foreach ($stylesheets as $name => $stylesheet) {
        $final_stylesheets[$media][$name] = $stylesheet;
      }
    }
  }
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
  if (!empty($theme->info['stylesheets-remove'])) {
    foreach ($theme->info['stylesheets-remove'] as $basename) {
      $theme->stylesheets_remove[$basename] = $theme_path . '/' . $basename;

      if (isset($theme->stylesheets_override[$basename])) {
        unset($theme->stylesheets_override[$basename]);
      }
    }
  }
  if (!empty($theme->info['stylesheets-override'])) {
    foreach ($theme->info['stylesheets-override'] as $name) {
      $basename = drupal_basename($name);
      $theme->stylesheets_override[$basename] = $theme_path . '/' . $name;

      if (isset($theme->stylesheets_remove[$basename])) {
        unset($theme->stylesheets_remove[$basename]);
      }
    }
  }
215

216
217
  // And now add the stylesheets properly.
  $css = array();
218
219
  foreach ($final_stylesheets as $media => $stylesheets) {
    foreach ($stylesheets as $stylesheet) {
220
221
222
223
224
      $css['#attached']['css'][$stylesheet] = array(
        'group' => CSS_AGGREGATE_THEME,
        'every_page' => TRUE,
        'media' => $media
      );
225
226
    }
  }
227
  drupal_render($css);
228

229
230
  // Do basically the same as the above for libraries
  $final_libraries = array();
231

232
  // Grab libraries from base theme
233
  foreach ($base_theme as $base) {
234
235
236
    if (!empty($base->libraries)) {
      foreach ($base->libraries as $library) {
        $final_libraries[] = $library;
237
      }
Dries's avatar
   
Dries committed
238
239
    }
  }
240

241
242
243
244
  // Add libraries used by this theme.
  if (!empty($theme->libraries)) {
    foreach ($theme->libraries as $library) {
      $final_libraries[] = $library;
245
246
247
    }
  }

248
249
250
251
  // Add libraries used by this theme.
  $libraries = array();
  foreach ($final_libraries as $library) {
    $libraries['#attached']['library'][] = $library;
252
  }
253
  drupal_render($libraries);
254

255
256
257
258
259
  $theme_engine = NULL;

  // Initialize the theme.
  if (isset($theme->engine)) {
    // Include the engine.
260
    include_once DRUPAL_ROOT . '/' . $theme->owner;
261
262

    $theme_engine = $theme->engine;
263
    if (function_exists($theme_engine . '_init')) {
264
      foreach ($base_theme as $base) {
265
        call_user_func($theme_engine . '_init', $base);
266
      }
267
      call_user_func($theme_engine . '_init', $theme);
268
269
270
271
272
273
274
    }
  }
  else {
    // include non-engine theme files
    foreach ($base_theme as $base) {
      // Include the theme file or the engine.
      if (!empty($base->owner)) {
275
        include_once DRUPAL_ROOT . '/' . $base->owner;
276
277
278
279
      }
    }
    // and our theme gets one too.
    if (!empty($theme->owner)) {
280
      include_once DRUPAL_ROOT . '/' . $theme->owner;
Dries's avatar
   
Dries committed
281
282
    }
  }
283
284

  // Always include Twig as the default theme engine.
285
  include_once DRUPAL_ROOT . '/core/themes/engines/twig/twig.engine';
Dries's avatar
   
Dries committed
286
287
}

288
/**
289
 * Gets the theme registry.
290
 *
291
 * @param bool $complete
292
 *   Optional boolean to indicate whether to return the complete theme registry
293
294
295
296
297
298
299
 *   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.
300
 *
301
 * @return
302
303
 *   The complete theme registry array, or an instance of the
 *   Drupal\Core\Utility\ThemeRegistry class.
304
 */
305
function theme_get_registry($complete = TRUE) {
306
  $theme_registry = \Drupal::service('theme.registry');
307
  if ($complete) {
308
    return $theme_registry->get();
309
310
  }
  else {
311
    return $theme_registry->getRuntime();
312
313
314
315
  }
}

/**
316
317
318
319
 * 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.
320
 */
321
function drupal_theme_rebuild() {
322
  \Drupal::service('theme.registry')->reset();
323
324
}

Dries's avatar
   
Dries committed
325
/**
326
 * Returns a list of all currently available themes.
Dries's avatar
   
Dries committed
327
 *
328
329
 * Retrieved from the database, if available and the site is not in maintenance
 * mode; otherwise compiled freshly from the filesystem.
330
 *
Dries's avatar
   
Dries committed
331
 * @param $refresh
332
 *   Whether to reload the list of themes from the database. Defaults to FALSE.
333
 *
334
335
 * @return array
 *   An associative array of the currently available themes.
336
 *
337
338
339
340
 * @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().
341
 */
342
function list_themes($refresh = FALSE) {
343
344
  /** @var \Drupal\Core\Extension\ThemeHandler $theme_handler */
  $theme_handler = \Drupal::service('theme_handler');
Dries's avatar
   
Dries committed
345
346

  if ($refresh) {
347
    $theme_handler->reset();
348
    system_list_reset();
Dries's avatar
   
Dries committed
349
350
  }

351
  return $theme_handler->listInfo();
Dries's avatar
   
Dries committed
352
353
}

Dries's avatar
   
Dries committed
354
/**
355
 * Generates themed output (internal use only).
356
 *
357
358
359
360
361
362
363
364
 * _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.
365
 *
366
367
368
369
370
371
 * 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.
372
 *
373
 * @param $hook
374
375
 *   The name of the theme hook to call. If the name contains a
 *   double-underscore ('__') and there isn't an implementation for the full
376
 *   name, the part before the '__' is checked. This allows a fallback to a
377
 *   more generic implementation. For example, if _theme('links__node', ...) is
378
379
 *   called, but there is no implementation of that theme hook, then the
 *   'links' implementation is used. This process is iterative, so if
380
 *   _theme('links__contextual__node', ...) is called, _theme() checks for the
381
382
383
384
385
386
 *   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
387
 *   may also be an array, in which case the first theme hook that has an
388
 *   implementation is used. This allows for the code that calls _theme() to
389
 *   explicitly specify the fallback order in a situation where using the '__'
390
 *   convention is not desired or is insufficient.
391
392
 * @param $variables
 *   An associative array of variables to merge with defaults from the theme
393
394
395
396
 *   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.
397
 *
398
399
400
 * @return string|false
 *   An HTML string representing the themed output or FALSE if the passed $hook
 *   is not implemented.
401
 *
402
 * @see drupal_render()
403
 * @see themeable
404
405
 * @see hook_theme()
 * @see template_preprocess()
Dries's avatar
   
Dries committed
406
 */
407
function _theme($hook, $variables = array()) {
408
  static $default_attributes;
409
410
411

  $module_handler = \Drupal::moduleHandler();

412
413
  // 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
414
  // request properly. See also \Drupal\Core\Theme\Registry::get().
415
  if (!$module_handler->isLoaded() && !defined('MAINTENANCE_MODE')) {
416
    throw new Exception(t('_theme() may not be called until all modules are loaded.'));
417
  }
418
419
  // Ensure the theme is initialized.
  drupal_theme_initialize();
420

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

424
425
  // If an array of hook candidates were passed, use the first one that has an
  // implementation.
426
427
  if (is_array($hook)) {
    foreach ($hook as $candidate) {
428
      if ($theme_registry->has($candidate)) {
429
430
431
432
433
        break;
      }
    }
    $hook = $candidate;
  }
434
435
436
  // Save the original theme hook, so it can be supplied to theme variable
  // preprocess callbacks.
  $original_hook = $hook;
437

438
439
  // If there's no implementation, check for more generic fallbacks. If there's
  // still no implementation, log an error and return an empty string.
440
  if (!$theme_registry->has($hook)) {
441
442
443
444
    // Iteratively strip everything after the last '__' delimiter, until an
    // implementation is found.
    while ($pos = strrpos($hook, '__')) {
      $hook = substr($hook, 0, $pos);
445
      if ($theme_registry->has($hook)) {
446
447
448
        break;
      }
    }
449
    if (!$theme_registry->has($hook)) {
450
451
452
      // Only log a message when not trying theme suggestions ($hook being an
      // array).
      if (!isset($candidate)) {
453
        watchdog('theme', 'Theme hook %hook not found.', array('%hook' => $hook), WATCHDOG_WARNING);
454
      }
455
      // There is no theme implementation for the hook passed. Return FALSE so
456
      // the function calling _theme() can differentiate between a hook that
457
458
      // exists and renders an empty string and a hook that is not implemented.
      return FALSE;
459
    }
460
461
  }

462
  $info = $theme_registry->get($hook);
463
464
465
  global $theme_path;
  $temp = $theme_path;
  // point path_to_theme() to the currently used theme path:
466
  $theme_path = $info['theme path'];
Dries's avatar
   
Dries committed
467

468
469

  // If a renderable array is passed as $variables, then set $variables to
470
  // the arguments expected by the theme function.
471
472
473
  if (isset($variables['#theme']) || isset($variables['#theme_wrappers'])) {
    $element = $variables;
    $variables = array();
474
475
    if (isset($info['variables'])) {
      foreach (array_keys($info['variables']) as $name) {
476
        if (isset($element["#$name"]) || array_key_exists("#$name", $element)) {
477
478
          $variables[$name] = $element["#$name"];
        }
479
480
      }
    }
481
482
    else {
      $variables[$info['render element']] = $element;
483
484
      // Give a hint to render engines to prevent infinite recursion.
      $variables[$info['render element']]['#render_children'] = TRUE;
485
    }
486
  }
487

488
  // Merge in argument defaults.
489
490
491
492
493
  if (!empty($info['variables'])) {
    $variables += $info['variables'];
  }
  elseif (!empty($info['render element'])) {
    $variables += array($info['render element'] => array());
494
  }
495
496
497
498
  // Supply original caller info.
  $variables += array(
    'theme_hook_original' => $original_hook,
  );
499

500
501
502
503
504
505
506
507
508
509
510
511
  // 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().
512
  $suggestions = $module_handler->invokeAll('theme_suggestions_' . $base_theme_hook, array($variables));
513
  // If _theme() was invoked with a direct theme suggestion like
514
515
516
517
518
  // '#theme' => 'node__article', add it to the suggestions array before
  // invoking suggestion alter hooks.
  if (isset($info['base hook'])) {
    $suggestions[] = $hook;
  }
519
520
521
522
523
524
525

  // Invoke hook_theme_suggestions_alter() and
  // hook_theme_suggestions_HOOK_alter().
  $hooks = array(
    'theme_suggestions',
    'theme_suggestions_' . $base_theme_hook,
  );
526
  $module_handler->alter($hooks, $suggestions, $variables, $base_theme_hook);
527
528

  // Check if each suggestion exists in the theme registry, and if so,
529
530
  // use it instead of the hook that _theme() was called with. For example, a
  // function may call _theme('node', ...), but a module can add
531
532
533
  // '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) {
534
535
    if ($theme_registry->has($suggestion)) {
      $info = $theme_registry->get($suggestion);
536
537
538
539
      break;
    }
  }

540
541
542
543
544
545
546
547
  // 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;
    }
  }

548
  // Invoke the variable preprocessors, if any.
549
550
  if (isset($info['base hook'])) {
    $base_hook = $info['base hook'];
551
    $base_hook_info = $theme_registry->get($base_hook);
552
    // Include files required by the base hook, since its variable preprocessors
553
554
555
556
557
558
    // might reside there.
    if (!empty($base_hook_info['includes'])) {
      foreach ($base_hook_info['includes'] as $include_file) {
        include_once DRUPAL_ROOT . '/' . $include_file;
      }
    }
559
    // Replace the preprocess functions with those from the base hook.
560
    if (isset($base_hook_info['preprocess functions'])) {
561
562
563
564
      // 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'];
565
566
    }
  }
567
568
569
570
  if (isset($info['preprocess functions'])) {
    foreach ($info['preprocess functions'] as $preprocessor_function) {
      if (function_exists($preprocessor_function)) {
        $preprocessor_function($variables, $hook, $info);
571
      }
572
573
    }
  }
574

575
  // Generate the output using either a function or a template.
576
  $output = '';
577
  if (isset($info['function'])) {
578
    if (function_exists($info['function'])) {
579
      $output = $info['function']($variables);
Dries's avatar
   
Dries committed
580
    }
Dries's avatar
   
Dries committed
581
  }
582
  else {
583
584
    $render_function = 'twig_render_template';
    $extension = '.html.twig';
585

586
    // The theme engine may use a different extension and a different renderer.
587
588
    global $theme_engine;
    if (isset($theme_engine)) {
589
      if ($info['type'] != 'module') {
590
591
        if (function_exists($theme_engine . '_render_template')) {
          $render_function = $theme_engine . '_render_template';
592
        }
593
        $extension_function = $theme_engine . '_extension';
594
595
596
597
598
599
        if (function_exists($extension_function)) {
          $extension = $extension_function();
        }
      }
    }

600
601
602
603
604
    // 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
605
606
607
608
609
    // 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.
610
611
    if (!isset($variables['directory'])) {
      $default_template_variables = array();
612
      template_preprocess($default_template_variables, $hook, $info);
613
614
      $variables += $default_template_variables;
    }
615
616
617
618
619
620
621
622
623
624
625
626
627
628
    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;
        }
      }
    }
629

630
631
632
633
    // Render the output using the template file.
    $template_file = $info['template'] . $extension;
    if (isset($info['path'])) {
      $template_file = $info['path'] . '/' . $template_file;
634
    }
635
636
637
638
639
640
641
642
643
644
    // 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
    // '#theme' => 'menu_tree__shortcut_default' when the template exists in the
    // current theme.
    if (isset($theme_hook_suggestion)) {
      $variables['theme_hook_suggestion'] = $theme_hook_suggestion;
    }
645
    $output = $render_function($template_file, $variables);
Dries's avatar
   
Dries committed
646
  }
647

648
649
  // restore path_to_theme()
  $theme_path = $temp;
650
  return (string) $output;
651
652
}

Dries's avatar
   
Dries committed
653
/**
654
655
656
657
658
659
660
661
 * Returns the path to the current themed element.
 *
 * It can point to the active theme or the module handling a themed
 * implementation. For example, when invoked within the scope of a theming call
 * it will depend on where the theming function is handled. If implemented from
 * a module, it will point to the module. If implemented from the active theme,
 * it will point to the active theme. When called outside the scope of a
 * theming call, it will always point to the active theme.
Dries's avatar
   
Dries committed
662
 */
Dries's avatar
   
Dries committed
663
function path_to_theme() {
664
  global $theme_path;
Dries's avatar
   
Dries committed
665

666
  if (!isset($theme_path)) {
667
    drupal_theme_initialize();
668
669
  }

670
  return $theme_path;
671
672
}

673
/**
674
 * Allows themes and/or theme engines to discover overridden theme functions.
675
676
677
678
679
680
 *
 * @param $cache
 *   The existing cache of theme hooks to test against.
 * @param $prefixes
 *   An array of prefixes to test, in reverse order of importance.
 *
681
 * @return $implementations
682
683
684
 *   The functions found, suitable for returning from hook_theme;
 */
function drupal_find_theme_functions($cache, $prefixes) {
685
  $implementations = array();
686
687
688
689
  $functions = get_defined_functions();

  foreach ($cache as $hook => $info) {
    foreach ($prefixes as $prefix) {
690
691
692
693
694
695
      // 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
696
      // the same base hook. To keep things simple, deep hierarchy of
697
698
699
700
      // 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.
701
      $pattern = isset($info['pattern']) ? $info['pattern'] : ($hook . '__');
702
      if (!isset($info['base hook']) && !empty($pattern)) {
703
        $matches = preg_grep('/^' . $prefix . '_' . $pattern . '/', $functions['user']);
704
705
        if ($matches) {
          foreach ($matches as $match) {
706
            $new_hook = substr($match, strlen($prefix) + 1);
707
            $arg_name = isset($info['variables']) ? 'variables' : 'render element';
708
            $implementations[$new_hook] = array(
709
              'function' => $match,
710
              $arg_name => $info[$arg_name],
711
              'base hook' => $hook,
712
713
714
715
            );
          }
        }
      }
716
717
718
      // 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.
719
      if (function_exists($prefix . '_' . $hook)) {
720
        $implementations[$hook] = array(
721
          'function' => $prefix . '_' . $hook,
722
723
724
725
726
        );
      }
    }
  }

727
  return $implementations;
728
729
730
}

/**
731
 * Allows themes and/or theme engines to easily discover overridden templates.
732
733
734
735
736
737
738
739
740
 *
 * @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) {
741
  $implementations = array();
742

743
744
745
746
  // 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();
747
  foreach (list_themes() as $theme_info) {
748
    if (!empty($theme_info->base_theme)) {
749
      $theme_paths[$theme_info->base_theme][$theme_info->getName()] = $theme_info->getPath();
750
751
752
753
754
755
756
    }
  }
  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]);
      }
757
758
    }
  }
759
760
  global $theme;
  $subtheme_paths = isset($theme_paths[$theme]) ? $theme_paths[$theme] : array();
761

762
  // Escape the periods in the extension.
763
  $regex = '/' . str_replace('.', '\.', $extension) . '$/';
764
  // Get a listing of all template files in the path to search.
765
  $files = file_scan_directory($path, $regex, array('key' => 'filename'));
766
767
768
769

  // 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.
770
  foreach ($files as $template => $file) {
771
    // Ignore sub-theme templates for the current theme.
772
    if (strpos($file->uri, str_replace($subtheme_paths, '', $file->uri)) !== 0) {
773
774
      continue;
    }
775
776
    // Remove the extension from the filename.
    $template = str_replace($extension, '', $template);
777
778
779
780
    // Transform - in filenames to _ to match function naming scheme
    // for the purposes of searching.
    $hook = strtr($template, '-', '_');
    if (isset($cache[$hook])) {
781
      $implementations[$hook] = array(
782
        'template' => $template,
783
        'path' => dirname($file->uri),
784
785
      );
    }
786
787
788
789

    // Match templates based on the 'template' filename.
    foreach ($cache as $hook => $info) {
      if (isset($info['template'])) {
790
        $template_candidates = array($info['template'], str_replace($info['theme path'] . '/templates/', '', $info['template']));
791
792
793
794
795
796
797
798
        if (in_array($template, $template_candidates)) {
          $implementations[$hook] = array(
            'template' => $template,
            'path' => dirname($file->uri),
          );
        }
      }
    }
799
800
  }

801
  // Find templates that implement possible "suggestion" variants of registered
802
  // theme hooks and add those as new registered theme hooks. See
803
804
  // drupal_find_theme_functions() for more information about suggestions and
  // the use of 'pattern' and 'base hook'.
805
806
  $patterns = array_keys($files);
  foreach ($cache as $hook => $info) {
807
    $pattern = isset($info['pattern']) ? $info['pattern'] : ($hook . '__');
808
    if (!isset($info['base hook']) && !empty($pattern)) {
809
810
      // Transform _ in pattern to - to match file naming scheme
      // for the purposes of searching.
811
      $pattern = strtr($pattern, '_', '-');
812

813
      $matches = preg_grep('/^' . $pattern . '/', $patterns);
814
815
      if ($matches) {
        foreach ($matches as $match) {
816
          $file = $match;
817
818
          // Remove the extension from the filename.
          $file = str_replace($extension, '', $file);
819
820
          // Put the underscores back in for the hook name and register this
          // pattern.
821
          $arg_name = isset($info['variables']) ? 'variables' : 'render element';
822
          $implementations[strtr($file, '-', '_')] = array(
823
            'template' => $file,
824
            'path' => dirname($files[$match]->uri),
825
            $arg_name => $info[$arg_name],
826
            'base hook' => $hook,
827
828
829
830
831
          );
        }
      }
    }
  }
832
  return $implementations;
833
834
}

Dries's avatar
   
Dries committed
835
/**
836
 * Retrieves a setting for the current theme or for a given theme.
Dries's avatar
   
Dries committed
837
 *
838
839
 * The final setting is obtained from the last value found in the following
 * sources:
840
841
842
 * - 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
843
844
845
846
 * - 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
847
848
 *
 * @param $setting_name
849
 *   The name of the setting to be retrieved.
850
 * @param $theme
851
852
 *   The name of a given theme; defaults to the current theme.
 *
Dries's avatar
   
Dries committed
853
854
855
 * @return
 *   The value of the requested setting, NULL if the setting does not exist.
 */
856
857
function theme_get_setting($setting_name, $theme = NULL) {
  $cache = &drupal_static(__FUNCTION__, array());
Dries's avatar
   
Dries committed
858

859
  // If no key is given, use the current theme if we can determine it.
860
  if (!isset($theme)) {
861
    $theme = !empty($GLOBALS['theme_key']) ? $GLOBALS['theme_key'] : '';
862
  }
Dries's avatar
   
Dries committed
863

864
  if (empty($cache[$theme])) {
865
866
    // Create a theme settings object.
    $cache[$theme] = new ThemeSettings($theme);
867

868
869
    // Get the values for the theme-specific settings from the .info.yml files
    // of the theme and all its base themes.
870
871
    $themes = list_themes();
    if ($theme && isset($themes[$theme])) {
872
873
874
875
876
877
      $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
878
      }
879
880
881
      else {
        $theme_keys = array($theme);
      }
882
      // Read hard-coded default settings from the theme info files.
883
884
      foreach ($theme_keys as $theme_key) {
        if (!empty($themes[$theme_key]->info['settings'])) {
885
          $cache[$theme]->merge($themes[$theme_key]->info['settings']);
886
        }
Dries's avatar
   
Dries committed
887
888
889
      }
    }

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

893
    if ($theme && isset($themes[$theme])) {
894
895
896
897
898
899
900
901
      // Retrieve configured theme-specific settings, if any.
      try {
        if ($theme_settings = \Drupal::config($theme . '.settings')->get()) {
          $cache[$theme]->merge($theme_settings);
        }
      }
      catch (StorageException $e) {
      }
902

903
904
905
      // 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'])) {
906
        foreach (_system_default_theme_features() as $feature) {
907
          if (!in_array($feature, $theme_object->info['features'])) {
908
            $cache[$theme]->set('features.' . $feature, NULL);
909
910
911
912
          }
        }
      }

913
      // Generate the path to the logo image.
914
915
916
      if ($cache[$theme]->get('features.logo')) {
        $logo_path = $cache[$theme]->get('logo.path');
        if ($cache[$theme]->get('logo.use_default')) {
917
          $cache[$theme]->set('logo.url', file_create_url($theme_object->getPath() . '/logo.png'));
918
        }
919
920
        elseif ($logo_path) {
          $cache[$theme]->set('logo.url', file_create_url($logo_path));
921
922
        }
      }
923
924

      // Generate the path to the favicon.
925
926
927
      if ($cache[$theme]->get('features.favicon')) {
        $favicon_path = $cache[$theme]->get('favicon.path');
        if ($cache[$theme]->get('favicon.use_default')) {
928
          if (file_exists($favicon = $theme_object->getPath() . '/favicon.ico')) {
929
            $cache[$theme]->set('favicon.url', file_create_url($favicon));
930
931
          }
          else {
932
            $cache[$theme]->set('favicon.url', file_create_url('core/misc/favicon.ico'));
933
934
          }
        }
935
936
        elseif ($favicon_path) {
          $cache[$theme]->set('favicon.url', file_create_url($favicon_path));
937
938
        }
        else {
939
          $cache[$theme]->set('features.favicon', FALSE);
940
        }
941
      }
942
    }
Dries's avatar
   
Dries committed
943
944
  }

945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
  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
986
987
}

988
/**