<?php

// $Id: theme.inc,v 1.415.2.24 2009/06/18 12:04:04 goba Exp $

/**

 * @file

 * The theme system, which controls the output of Drupal.

 *

 * The theme system allows for nearly all output of the Drupal system to be

 * customized by user themes.

 *

 * @ingroup themeable

 */

/**

 * @name Content markers

 * @{

 * Markers used by theme_mark() and node_mark() to designate content.

 * @see theme_mark(), node_mark()

 */

define('MARK_READ',    0);

define('MARK_NEW',     1);

define('MARK_UPDATED', 2);

/**

 * @} End of "Content markers".

 */

/**

 * Initialize the theme system by loading the theme.

 */

function init_theme() {

  global $theme, $user, $custom_theme, $theme_key;

  // If $theme is already set, assume the others are set, too, and do nothing

  if (isset($theme)) {

    return;

  }

  drupal_bootstrap(DRUPAL_BOOTSTRAP_DATABASE);

  $themes = list_themes();

  // Only select the user selected theme if it is available in the

  // list of enabled themes.

  $theme = !empty($user->theme) && !empty($themes[$user->theme]->status) ? $user->theme : variable_get('theme_default', 'garland');

  // Allow modules to override the present theme... only select custom theme

  // if it is available in the list of installed themes.

  $theme = $custom_theme && $themes[$custom_theme] ? $custom_theme : $theme;

  // Store the identifier for retrieving theme settings with.

  $theme_key = $theme;

  // Find all our ancestor themes and put them in an array.

  $base_theme = array();

  $ancestor = $theme;

  while ($ancestor && isset($themes[$ancestor]->base_theme)) {

    $base_theme[] = $new_base_theme = $themes[$themes[$ancestor]->base_theme];

    $ancestor = $themes[$ancestor]->base_theme;

  }

  _init_theme($themes[$theme], array_reverse($base_theme));

}

/**

 * Initialize the theme system given already loaded information. This

 * function is useful to initialize a theme when no database is present.

 *

 * @param $theme

 *   An object with the following information:

 *     filename

 *       The .info file for this theme. The 'path' to

 *       the theme will be in this file's directory. (Required)

 *     owner

 *       The path to the .theme file or the .engine file to load for

 *       the theme. (Required)

 *     stylesheet

 *       The primary stylesheet for the theme. (Optional)

 *     engine

 *       The name of theme engine to use. (Optional)

 * @param $base_theme

 *    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.

 * @param $registry_callback

 *   The callback to invoke to set the theme registry.

 */

function _init_theme($theme, $base_theme = array(), $registry_callback = '_theme_load_registry') {

  global $theme_info, $base_theme_info, $theme_engine, $theme_path;

  $theme_info = $theme;

  $base_theme_info = $base_theme;

  $theme_path = dirname($theme->filename);

  // 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();

  // 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;

        }

      }

    }

  }

  // Add stylesheets used by this theme.

  if (!empty($theme->stylesheets)) {

    foreach ($theme->stylesheets as $media => $stylesheets) {

      foreach ($stylesheets as $name => $stylesheet) {

        $final_stylesheets[$media][$name] = $stylesheet;

      }

    }

  }

  // And now add the stylesheets properly

  foreach ($final_stylesheets as $media => $stylesheets) {

    foreach ($stylesheets as $stylesheet) {

      drupal_add_css($stylesheet, 'theme', $media);

    }

  }

  // Do basically the same as the above for scripts

  $final_scripts = array();

  // Grab scripts from base theme

  foreach ($base_theme as $base) {

    if (!empty($base->scripts)) {

      foreach ($base->scripts as $name => $script) {

        $final_scripts[$name] = $script;

      }

    }

  }

  // Add scripts used by this theme.

  if (!empty($theme->scripts)) {

    foreach ($theme->scripts as $name => $script) {

      $final_scripts[$name] = $script;

    }

  }

  // Add scripts used by this theme.

  foreach ($final_scripts as $script) {

    drupal_add_js($script, 'theme');

  }

  $theme_engine = NULL;

  // Initialize the theme.

  if (isset($theme->engine)) {

    // Include the engine.

    include_once './'. $theme->owner;

    $theme_engine = $theme->engine;

    if (function_exists($theme_engine .'_init')) {

      foreach ($base_theme as $base) {

        call_user_func($theme_engine .'_init', $base);

      }

      call_user_func($theme_engine .'_init', $theme);

    }

  }

  else {

    // include non-engine theme files

    foreach ($base_theme as $base) {

      // Include the theme file or the engine.

      if (!empty($base->owner)) {

        include_once './'. $base->owner;

      }

    }

    // and our theme gets one too.

    if (!empty($theme->owner)) {

      include_once './'. $theme->owner;

    }

  }

  $registry_callback($theme, $base_theme, $theme_engine);

}

/**

 * Retrieve the stored theme registry. If the theme registry is already

 * in memory it will be returned; otherwise it will attempt to load the

 * registry from cache. If this fails, it will construct the registry and

 * cache it.

 */

function theme_get_registry($registry = NULL) {

  static $theme_registry = NULL;

  if (isset($registry)) {

    $theme_registry = $registry;

  }

  return $theme_registry;

}

/**

 * Store the theme registry in memory.

 */

function _theme_set_registry($registry) {

  // Pass through for setting of static variable.

  return theme_get_registry($registry);

}

/**

 * Get the theme_registry cache from the database; if it doesn't exist, build

 * it.

 *

 * @param $theme

 *   The loaded $theme object.

 * @param $base_theme

 *   An array of loaded $theme objects representing the ancestor themes in

 *   oldest first order.

 * @param theme_engine

 *   The name of the theme engine.

 */

function _theme_load_registry($theme, $base_theme = NULL, $theme_engine = NULL) {

  // Check the theme registry cache; if it exists, use it.

  $cache = cache_get("theme_registry:$theme->name", 'cache');

  if (isset($cache->data)) {

    $registry = $cache->data;

  }

  else {

    // If not, build one and cache it.

    $registry = _theme_build_registry($theme, $base_theme, $theme_engine);

    _theme_save_registry($theme, $registry);

  }

  _theme_set_registry($registry);

}

/**

 * Write the theme_registry cache into the database.

 */

function _theme_save_registry($theme, $registry) {

  cache_set("theme_registry:$theme->name", $registry);

}

/**

 * Force the system to rebuild the theme registry; this should be called

 * when modules are added to the system, or when a dynamic system needs

 * to add more theme hooks.

 */

function drupal_rebuild_theme_registry() {

  cache_clear_all('theme_registry', 'cache', TRUE);

}

/**

 * Process a single invocation of the theme hook. $type will be one

 * of 'module', 'theme_engine', 'base_theme_engine', 'theme', or 'base_theme'

 * and it tells us some important information.

 *

 * Because $cache is a reference, the cache will be continually

 * expanded upon; new entries will replace old entries in the

 * array_merge, but we are careful to ensure some data is carried

 * forward, such as the arguments a theme hook needs.

 *

 * An override flag can be set for preprocess functions. When detected the

 * cached preprocessors for the hook will not be merged with the newly set.

 * This can be useful to themes and theme engines by giving them more control

 * over how and when the preprocess functions are run.

 */

function _theme_process_registry(&$cache, $name, $type, $theme, $path) {

  $result = array();

  $function = $name .'_theme';

  if (function_exists($function)) {

    $result = $function($cache, $type, $theme, $path);

    foreach ($result as $hook => $info) {

      $result[$hook]['type'] = $type;

      $result[$hook]['theme path'] = $path;

      // if function and file are left out, default to standard naming

      // conventions.

      if (!isset($info['template']) && !isset($info['function'])) {

        $result[$hook]['function'] = ($type == 'module' ? 'theme_' : $name .'_') . $hook;

      }

      // If a path is set in the info, use what was set. Otherwise use the

      // default path. This is mostly so system.module can declare theme

      // functions on behalf of core .include files.

      // All files are included to be safe. Conditionally included

      // files can prevent them from getting registered.

      if (isset($info['file']) && !isset($info['path'])) {

        $result[$hook]['file'] = $path .'/'. $info['file'];

        include_once($result[$hook]['file']);

      }

      elseif (isset($info['file']) && isset($info['path'])) {

        include_once($info['path'] .'/'. $info['file']);

      }

      if (isset($info['template']) && !isset($info['path'])) {

        $result[$hook]['template'] = $path .'/'. $info['template'];

      }

      // If 'arguments' have been defined previously, carry them forward.

      // This should happen if a theme overrides a Drupal defined theme

      // function, for example.

      if (!isset($info['arguments']) && isset($cache[$hook])) {

        $result[$hook]['arguments'] = $cache[$hook]['arguments'];

      }

      // Likewise with theme paths. These are used for template naming suggestions.

      // Theme implementations can occur in multiple paths. Suggestions should follow.

      if (!isset($info['theme paths']) && isset($cache[$hook])) {

        $result[$hook]['theme paths'] = $cache[$hook]['theme paths'];

      }

      // Check for sub-directories.

      $result[$hook]['theme paths'][] = isset($info['path']) ? $info['path'] : $path;

      // Check for default _preprocess_ functions. Ensure arrayness.

      if (!isset($info['preprocess functions']) || !is_array($info['preprocess functions'])) {

        $info['preprocess functions'] = array();

        $prefixes = array();

        if ($type == 'module') {

          // Default preprocessor prefix.

          $prefixes[] = 'template';

          // Add all modules so they can intervene with their own preprocessors. This allows them

          // to provide preprocess functions even if they are not the owner of the current hook.

          $prefixes += module_list();

        }

        elseif ($type == 'theme_engine' || $type == 'base_theme_engine') {

          // Theme engines get an extra set that come before the normally named preprocessors.

          $prefixes[] = $name .'_engine';

          // The theme engine also registers on behalf of the theme. The theme or engine name can be used.

          $prefixes[] = $name;

          $prefixes[] = $theme;

        }

        else {

          // This applies when the theme manually registers their own preprocessors.

          $prefixes[] = $name;

        }

        foreach ($prefixes as $prefix) {

          if (function_exists($prefix .'_preprocess')) {

            $info['preprocess functions'][] = $prefix .'_preprocess';

          }

          if (function_exists($prefix .'_preprocess_'. $hook)) {

            $info['preprocess functions'][] = $prefix .'_preprocess_'. $hook;

          }

          if (!empty($info['original hook']) && function_exists($prefix .'_preprocess_'. $info['original hook'])) {

            $info['preprocess functions'][] = $prefix .'_preprocess_'. $info['original hook'];

          }

        }

      }

      // Check for the override flag and prevent the cached preprocess functions from being used.

      // This allows themes or theme engines to remove preprocessors set earlier in the registry build.

      if (!empty($info['override preprocess functions'])) {

        // Flag not needed inside the registry.

        unset($result[$hook]['override preprocess functions']);

      }

      elseif (isset($cache[$hook]['preprocess functions']) && is_array($cache[$hook]['preprocess functions'])) {

        $info['preprocess functions'] = array_merge($cache[$hook]['preprocess functions'], $info['preprocess functions']);

      }

      elseif (isset($info['original hook']) && isset($cache[$info['original hook']]['preprocess functions']) && is_array($cache[$info['original hook']]['preprocess functions'])) {

        $info['preprocess functions'] = array_merge($cache[$info['original hook']]['preprocess functions'], $info['preprocess functions']);

      }

      $result[$hook]['preprocess functions'] = $info['preprocess functions'];

    }

    // Merge the newly created theme hooks into the existing cache.

    $cache = array_merge($cache, $result);

  }

  // Let themes have preprocess functions even if they didn't register a template.

  if ($type == 'theme' || $type == 'base_theme') {

    foreach ($cache as $hook => $info) {

      // Check only if it's a template and not registered by the theme or engine.

      if (!empty($info['template']) && empty($result[$hook])) {

        if (!isset($info['preprocess functions'])) {

          $cache[$hook]['preprocess functions'] = array();

        }

        if (function_exists($name .'_preprocess')) {

          $cache[$hook]['preprocess functions'][] = $name .'_preprocess';

        }

        if (function_exists($name .'_preprocess_'. $hook)) {

          $cache[$hook]['preprocess functions'][] = $name .'_preprocess_'. $hook;

        }

        // Ensure uniqueness.

        $cache[$hook]['preprocess functions'] = array_unique($cache[$hook]['preprocess functions']);

      }

    }

  }

}

/**

 * Rebuild the hook theme_registry cache.

 *

 * @param $theme

 *   The loaded $theme object.

 * @param $base_theme

 *   An array of loaded $theme objects representing the ancestor themes in

 *   oldest first order.

 * @param theme_engine

 *   The name of the theme engine.

 */

function _theme_build_registry($theme, $base_theme, $theme_engine) {

  $cache = array();

  // First, process the theme hooks advertised by modules. This will

  // serve as the basic registry.

  foreach (module_implements('theme') as $module) {

    _theme_process_registry($cache, $module, 'module', $module, drupal_get_path('module', $module));

  }

  // Process each base theme.

  foreach ($base_theme as $base) {

    // If the base theme uses a theme engine, process its hooks.

    $base_path = dirname($base->filename);

    if ($theme_engine) {

      _theme_process_registry($cache, $theme_engine, 'base_theme_engine', $base->name, $base_path);

    }

    _theme_process_registry($cache, $base->name, 'base_theme', $base->name, $base_path);

  }

  // And then the same thing, but for the theme.

  if ($theme_engine) {

    _theme_process_registry($cache, $theme_engine, 'theme_engine', $theme->name, dirname($theme->filename));

  }

  // Finally, hooks provided by the theme itself.

  _theme_process_registry($cache, $theme->name, 'theme', $theme->name, dirname($theme->filename));