layout.module

The Layout module creates pages and wraps existing pages in layouts.
Backdrop's primary tool for positioning content is through layouts and blocks. A "layout" is the template that defines regions in which pieces of content may be placed. Each piece of content in this case is called a "block". Blocks may be placed multiple times in a single layout, and each block maintains separate settings. Each layout created saves to a configuration file, including all the settings for the blocks contained within it.
Layout module provides two distinct ways of rendering pages. It is capable of creating a stand-alone page that is created at any custom path specified by the user, and it can also "wrap" the content of any path provided by a module. In the case where a custom path is created, Layout module registers the path in the menu system through hook_menu(). For wrapping module-provided pages, Layout module declares itself as the system-wide "route handler", as checked in menu_execute_active_handler(). Layout module then becomes responsible for calling the module-provided content as a block, and positions other blocks around the existing content.
File

core/modules/layout/layout.module
View source
<?php
/**
 * @file
 * The Layout module creates pages and wraps existing pages in layouts.
 *
 * Backdrop's primary tool for positioning content is through layouts and
 * blocks. A "layout" is the template that defines regions in which pieces of
 * content may be placed. Each piece of content in this case is called a
 * "block". Blocks may be placed multiple times in a single layout, and each
 * block maintains separate settings. Each layout created saves to a
 * configuration file, including all the settings for the blocks contained
 * within it.
 *
 * Layout module provides two distinct ways of rendering pages. It is capable of
 * creating a stand-alone page that is created at any custom path specified by
 * the user, and it can also "wrap" the content of any path provided by a
 * module. In the case where a custom path is created, Layout module registers
 * the path in the menu system through hook_menu(). For wrapping module-provided
 * pages, Layout module declares itself as the system-wide "route handler", as
 * checked in menu_execute_active_handler(). Layout module then becomes
 * responsible for calling the module-provided content as a block, and positions
 * other blocks around the existing content.
 */

/**
 * Layouts constant for user-defined layouts.
 */
define('LAYOUT_STORAGE_NORMAL', 1);

/**
 * Layout constant for layouts that override module-defined presets.
 */
define('LAYOUT_STORAGE_OVERRIDE', 2);

/**
 * Layout constant for module-defined layouts.
 */
define('LAYOUT_STORAGE_DEFAULT', 4);

/**
 * Layout constant indicating the title of the layout is the default.
 */
define('LAYOUT_TITLE_DEFAULT', 'default');

/**
 * Layout constant indicating the title of the layout is not shown.
 */
define('LAYOUT_TITLE_NONE', 'none');

/**
 * Layout constant indicating the title of the layout is manually specified.
 */
define('LAYOUT_TITLE_CUSTOM', 'custom');

/**
 * Layout constant indicating the title of the layout comes from a block.
 */
define('LAYOUT_TITLE_BLOCK', 'block');

/**
 * Denotes that the block is disabled.
 */
define('BLOCK_DISABLED', 0);

/**
 * Denotes that the block is enabled.
 */
define('BLOCK_ENABLED', 1);

/**
 * Implements hook_menu().
 */
function layout_menu() {
  $items = array();

  $base = array(
    'access arguments' => array('administer layouts'),
    'theme callback' => 'ajax_base_page_theme',
  );

  $items['admin/structure/layouts'] = array(
    'title' => 'Layouts',
    'description' => 'Create new landing pages or modify the layout of existing pages on your site.',
    'page callback' => 'layout_list_page',
    'type' => MENU_NORMAL_ITEM,
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts'] += $base;

  $items['admin/structure/layouts/list'] = array(
    'title' => 'List layouts',
    'type' => MENU_DEFAULT_LOCAL_TASK,
    'weight' => -10,
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/list'] += $base;

  $items['admin/structure/layouts/settings'] = array(
    'title' => 'Layout templates',
    'description' => 'Manage layout templates.',
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('layout_settings_page'),
    'type' => MENU_LOCAL_TASK,
    'weight' => 20,
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/settings'] += $base;

  $items['admin/structure/layouts/settings/flexible-template/add'] = array(
    'title' => 'Add flexible layout template',
    'page callback' => 'layout_flexible_template_settings_add_form',
    'access arguments' => array('administer flexible templates'),
    'type' => MENU_LOCAL_ACTION,
    'weight' => -10,
    'file' => 'layout.flexible.inc',
  );
  $items['admin/structure/layouts/settings/flexible-template/add'] += $base;

  $items['admin/structure/layouts/settings/flexible-template/%layout_flexible_tempstore/edit'] = array(
    'title' => 'Configure flexible layout template',
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('layout_flexible_template_settings_edit_form', 5),
    'access arguments' => array('administer flexible templates'),
    'type' => MENU_NORMAL_ITEM,
    'weight' => -10,
    'file' => 'layout.flexible.inc',
  );
  $items['admin/structure/layouts/settings/flexible-template/%layout_flexible_tempstore/edit'] += $base;

  $items['admin/structure/layouts/settings/flexible-template/%layout_flexible_tempstore/configure'] = array(
    'title' => 'Configure flexible layout template',
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('layout_flexible_template_configure_form', 5),
    'access arguments' => array('administer flexible templates'),
    'type' => MENU_NORMAL_ITEM,
    'weight' => -10,
    'file' => 'layout.flexible.inc',
  );
  $items['admin/structure/layouts/settings/flexible-template/%layout_flexible_tempstore/configure'] += $base;

  $items['admin/structure/layouts/settings/flexible-template/%layout_flexible_tempstore/delete'] = array(
    'title' => 'Delete flexible layout template',
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('layout_flexible_template_delete_form', 5),
    'access arguments' => array('administer flexible templates'),
    'type' => MENU_NORMAL_ITEM,
    'weight' => -10,
    'file' => 'layout.flexible.inc',
  );
  $items['admin/structure/layouts/settings/flexible-template/%layout_flexible_tempstore/delete'] += $base;

  $items['admin/structure/layouts/settings/flexible-template/%layout_flexible_tempstore/row/%/delete'] = array(
    'title' => 'Delete row',
    'page callback' => 'layout_flexible_template_delete_row',
    'page arguments' => array(5, 7),
    'access arguments' => array('administer flexible templates'),
    'type' => MENU_CALLBACK,
    'weight' => -10,
    'file' => 'layout.flexible.inc',
  );
  $items['admin/structure/layouts/settings/flexible-template/%layout_flexible_tempstore/row/%/delete'] += $base;

  $items['admin/structure/layouts/settings/flexible-template/%layout_flexible_tempstore/row/%/select-widths'] = array(
    'title' => 'Choose region widths',
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('layout_flexible_template_region_style_select', 5, 7),
    'access arguments' => array('administer flexible templates'),
    'type' => MENU_CALLBACK,
    'weight' => -10,
    'file' => 'layout.flexible.inc',
  );
  $items['admin/structure/layouts/settings/flexible-template/%layout_flexible_tempstore/row/%/select-widths'] += $base;

  $items['admin/structure/layouts/settings/flexible-template/%layout_flexible_tempstore/row/%/configure'] = array(
    'title' => 'Add row',
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('layout_flexible_template_edit_row_form', 5, 7),
    'access arguments' => array('administer flexible templates'),
    'type' => MENU_CALLBACK,
    'weight' => -10,
    'file' => 'layout.flexible.inc',
  );
  $items['admin/structure/layouts/settings/flexible-template/%layout_flexible_tempstore/row/%/configure'] += $base;

  $items['admin/structure/layouts/settings/flexible-template/%layout_flexible_tempstore/row/%/configure/%'] = array(
    'title' => 'Add row',
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('layout_flexible_template_edit_row_form', 5, 7, 9),
    'access arguments' => array('administer flexible templates'),
    'type' => MENU_CALLBACK,
    'weight' => -10,
    'file' => 'layout.flexible.inc',
  );
  $items['admin/structure/layouts/settings/flexible-template/%layout_flexible_tempstore/row/%/configure/%'] += $base;

  $items['admin/structure/layouts/settings/toggle/%/enable'] = array(
    'title' => 'Enable layout template',
    'page callback' => 'layout_template_toggle_enabled',
    'page arguments' => array(5, TRUE),
    'type' => MENU_CALLBACK,
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/settings/toggle/%/enable'] += $base;

  $items['admin/structure/layouts/settings/toggle/%/disable'] = array(
    'title' => 'Disable layout template',
    'page callback' => 'layout_template_toggle_enabled',
    'page arguments' => array(5, FALSE),
    'type' => MENU_CALLBACK,
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/settings/toggle/%/disable'] += $base;

  $items['admin/structure/layouts/reorder'] = array(
    'title' => 'Reorder',
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('layout_reorder_form'),
    'type' => MENU_CALLBACK,
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/reorder'] += $base;

  $items['admin/structure/layouts/add'] = array(
    'title' => 'Add layout',
    'page callback' => 'layout_add_page',
    'page arguments' => array(),
    'type' => MENU_LOCAL_ACTION,
    'weight' => -10,
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/add'] += $base;

  $items['admin/structure/layouts/manage/%layout_tempstore'] = array(
    'title' => 'Manage blocks',
    'title callback' => 'layout_page_title',
    'title arguments' => array(4),
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('layout_content_form', 4),
    'type' => MENU_NORMAL_ITEM,
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/manage/%layout_tempstore'] += $base;

  // @deprecated: Remove backwards-compatibility redirect in 2.0.
  $items['admin/structure/layouts/manage/%layout_tempstore/edit'] = array(
    'page callback' => 'system_redirect_deprecated_page',
    'page arguments' => array('admin/structure/layouts/manage/%layout_tempstore/blocks'),
    'access arguments' => array('administer layouts'),
    'type' => MENU_CALLBACK,
  );
  $items['admin/structure/layouts/manage/%layout_tempstore/blocks'] = array(
    'title' => 'Manage blocks',
    'type' => MENU_DEFAULT_LOCAL_TASK,
    'weight' => 0,
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/manage/%layout_tempstore/blocks'] += $base;

  // @deprecated: Remove backwards-compatibility redirect in 2.0.
  $items['admin/structure/layouts/manage/%layout_tempstore/settings'] = array(
    'page callback' => 'system_redirect_deprecated_page',
    'page arguments' => array('admin/structure/layouts/manage/%layout_tempstore/configure'),
    'access arguments' => array('administer layouts'),
    'type' => MENU_CALLBACK,
  );
  $items['admin/structure/layouts/manage/%layout_tempstore/configure'] = array(
    'title' => 'Configure layout',
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('layout_settings_form', 4),
    'type' => MENU_LOCAL_TASK,
    'weight' => 10,
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/manage/%layout_tempstore/configure'] += $base;

  $items['admin/structure/layouts/manage/%layout_tempstore/add-block/%/%'] = array(
    'title' => 'Add block',
    'page callback' => 'layout_block_add_page',
    'page arguments' => array(4, 6, 7),
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/manage/%layout_tempstore/add-block/%/%'] += $base;

  $items['admin/structure/layouts/manage/%layout_tempstore/configure-region/%/%'] = array(
    'title' => 'Configure region',
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('layout_configure_region_page', 4, 6, 7),
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/manage/%layout_tempstore/configure-region/%/%'] += $base;

  $items['admin/structure/layouts/manage/%layout_tempstore/edit-title/editor/title'] = array(
    'title' => 'Configure page title',
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('layout_title_settings_form', 4),
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/manage/%layout_tempstore/edit-title/editor/title'] += $base;

  $items['admin/structure/layouts/manage/%layout_tempstore/configure-block/%/%layout_tempstore_block'] = array(
    'title' => 'Configure block',
    'load arguments' => array(4),
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('layout_block_configure_form', 4, 7, 6),
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/manage/%layout_tempstore/configure-block/%/%layout_tempstore_block'] += $base;

  // This shortcut path does not use layout_tempstore, for efficiency when
  // checking access to this path from contextual links. To work as a contextual
  // link, we have to specify the context and also set the type to be a
  // MENU_LOCAL_TASK, even though this page never shows up as a tab anywhere.
  $items['admin/structure/layouts/manage/%layout/configure-redirect/%'] = array(
    'title' => 'Configure block',
    'load arguments' => array(4),
    'page callback' => 'layout_block_configure_redirect',
    'page arguments' => array(4, 6),
    'context' => MENU_CONTEXT_INLINE,
    'type' => MENU_DEFAULT_LOCAL_TASK,
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/manage/%layout/configure-redirect/%'] += $base;

  $items['admin/structure/layouts/manage/%layout_tempstore/remove-block/%/%layout_tempstore_block'] = array(
    'title' => 'Remove block',
    'load arguments' => array(4),
    'page callback' => 'layout_block_remove_page',
    'page arguments' => array(4, 7, 6),
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/manage/%layout_tempstore/remove-block/%/%layout_tempstore_block'] += $base;

  $items['admin/structure/layouts/manage/%layout_tempstore/toggle-block-status/%/%layout_tempstore_block'] = array(
    'title' => 'Disable block',
    'load arguments' => array(4),
    'page callback' => 'layout_block_disable_page',
    'page arguments' => array(4, 7, 6),
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/manage/%layout_tempstore/toggle-block-status/%/%layout_tempstore_block'] += $base;

  $items['admin/structure/layouts/manage/%layout_tempstore/clone'] = array(
    'title' => 'Clone layout',
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('layout_clone_form', 4),
    'type' => MENU_CALLBACK,
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/manage/%layout_tempstore/clone'] += $base;

  $items['admin/structure/layouts/manage/%layout_tempstore/enable'] = array(
    'page callback' => 'layout_toggle_enabled',
    'page arguments' => array(4, TRUE),
    'type' => MENU_CALLBACK,
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/manage/%layout_tempstore/enable'] += $base;

  $items['admin/structure/layouts/manage/%layout_tempstore/disable'] = array(
    'page callback' => 'layout_toggle_enabled',
    'page arguments' => array(4, FALSE),
    'type' => MENU_CALLBACK,
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/manage/%layout_tempstore/disable'] += $base;

  $items['admin/structure/layouts/manage/%layout_tempstore/delete'] = array(
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('layout_delete_form', 4),
    'type' => MENU_CALLBACK,
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/manage/%layout_tempstore/delete'] += $base;

  $items['admin/structure/layouts/manage/%layout_tempstore/break-lock'] = array(
    'page callback' => 'layout_break_lock_page',
    'page arguments' => array(4, 'layout'),
    'type' => MENU_CALLBACK,
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/manage/%layout_tempstore/break-lock'] += $base;

  $items['admin/structure/layouts/manage/%layout_tempstore/context/add'] = array(
    'title' => 'Add context',
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('layout_context_add_form', 4),
    'type' => MENU_CALLBACK,
    'file' => 'layout.context.admin.inc',
  );
  $items['admin/structure/layouts/manage/%layout_tempstore/context/add'] += $base;

  $items['admin/structure/layouts/manage/%layout_tempstore/relationship/add'] = array(
    'title' => 'Add relationship',
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('layout_context_relationship_add_form', 4),
    'type' => MENU_CALLBACK,
    'file' => 'layout.context.admin.inc',
  );
  $items['admin/structure/layouts/manage/%layout_tempstore/relationship/add'] += $base;

  $items['admin/structure/layouts/manage/%layout_tempstore/context/edit/layout/%'] = array(
    'title' => 'Configure context',
    'load arguments' => array(4),
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('layout_context_add_form', 4, 8),
    'type' => MENU_CALLBACK,
    'file' => 'layout.context.admin.inc',
  );
  $items['admin/structure/layouts/manage/%layout_tempstore/context/edit/layout/%'] += $base;

  $items['admin/structure/layouts/manage/%layout_tempstore/relationship/edit/layout/%'] = array(
    'title' => 'Configure relationship',
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('layout_context_relationship_add_form', 4, 8),
    'type' => MENU_CALLBACK,
    'file' => 'layout.context.admin.inc',
  );
  $items['admin/structure/layouts/manage/%layout_tempstore/relationship/edit/layout/%'] += $base;

  $items['admin/structure/layouts/manage/%layout_tempstore/condition/add'] = array(
    'title' => 'Add visibility condition',
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('layout_condition_add_form', 4),
    'type' => MENU_CALLBACK,
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/manage/%layout_tempstore/condition/add'] += $base;

  $items['admin/structure/layouts/manage/%layout_tempstore/condition/edit/layout/%'] = array(
    'title' => 'Configure condition',
    'load arguments' => array(4),
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('layout_condition_add_form', 4, NULL, NULL, 8),
    'type' => MENU_CALLBACK,
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/manage/%layout_tempstore/condition/edit/layout/%'] += $base;

  $items['admin/structure/layouts/manage/%layout_tempstore/condition/add/%layout_tempstore_block'] = array(
    'title' => 'Add visibility condition',
    'load arguments' => array(4),
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('layout_condition_add_form', 4, 7),
    'type' => MENU_CALLBACK,
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/manage/%layout_tempstore/condition/add/%layout_tempstore_block'] += $base;

  $items['admin/structure/layouts/manage/%layout_tempstore/condition/edit/%layout_tempstore_block/%'] = array(
    'title' => 'Configure condition',
    'load arguments' => array(4),
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('layout_condition_add_form', 4, 7, NULL, 8),
    'type' => MENU_CALLBACK,
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/manage/%layout_tempstore/condition/edit/%layout_tempstore_block/%'] += $base;

  $items['admin/structure/layouts/menu/%layout_tempstore_menu_item'] = array(
    'title' => 'Menu settings',
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('layout_menu_item_form', 4),
    'type' => MENU_NORMAL_ITEM,
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/menu/%layout_tempstore_menu_item'] += $base;

  $items['admin/structure/layouts/menu/%layout_tempstore_menu_item/settings'] = array(
    'title' => 'Menu settings',
    'type' => MENU_DEFAULT_LOCAL_TASK,
    'weight' => -1,
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/menu/%layout_tempstore_menu_item/settings'] += $base;

  $items['admin/structure/layouts/menu/%layout_tempstore_menu_item/break-lock'] = array(
    'page callback' => 'layout_break_lock_page',
    'page arguments' => array(4, 'menu_item'),
    'type' => MENU_CALLBACK,
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/menu/%layout_tempstore_menu_item/break-lock'] += $base;

  $items['admin/structure/layouts/menu/%layout_tempstore_menu_item/condition/add'] = array(
    'title' => 'Add visibility condition',
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('layout_condition_add_form', NULL, NULL, 4),
    'type' => MENU_CALLBACK,
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/menu/%layout_tempstore_menu_item/condition/add'] += $base;

  $items['admin/structure/layouts/menu/%layout_tempstore_menu_item/condition/edit/%'] = array(
    'title' => 'Configure condition',
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('layout_condition_add_form', NULL, NULL, 4, 7),
    'type' => MENU_CALLBACK,
    'file' => 'layout.admin.inc',
  );
  $items['admin/structure/layouts/menu/%layout_tempstore_menu_item/condition/edit/%'] += $base;

  // Add menu entries for each custom layout path.
  foreach (layout_menu_item_load_all() as $menu_item) {
    if (!empty($menu_item->disabled)) {
      continue;
    }

    $path             = array();
    $page_arguments   = array($menu_item->name);
    $access_arguments = array($menu_item->name);
    $load_arguments   = array($menu_item->name, '%map', '%index');

    // Replace placeholders with named placeholders for known contexts.
    foreach (explode('/', $menu_item->path) as $position => $bit) {
      $placeholder = $bit;

      if (strpos($bit, '%') === 0) {
        $placeholder = '%layout_path';
      }

      $path[]             = $placeholder;
      $page_arguments[]   = $position;
      $access_arguments[] = $position;
    }

    $menu_path = implode('/', $path);
    $items[$menu_path] = layout_page_menu_item($menu_item->menu, $access_arguments, $page_arguments, $load_arguments);

    // Add a parent menu item if one is configured.
    if (isset($menu_item->menu['type']) && $menu_item->menu['type'] == 'default tab') {
      array_pop($path);
      $parent_path = implode('/', $path);
      $items[$parent_path] = layout_page_menu_item($menu_item->menu['parent'], $access_arguments, $page_arguments, $load_arguments);
    }
  }

  // A page in the Reports section to list all blocks and their modules.
  $items['admin/reports/blocks'] = array(
    'title' => 'Blocks',
    'description' => 'Overview of all blocks and their modules.',
    'page callback' => 'layout_block_list',
    'access callback' => 'user_access',
    'access arguments' => array('administer layouts'),
    'file' => 'layout.admin.inc',
  );

  // Create layout tabs for all possible entity bundles. Limit to entities that
  // define a menu context path.
  $all_info = _layout_get_all_info('layout_context');
  $entity_names = array();
  foreach ($all_info as $entity_type_name => $context_info) {
    if (!empty($context_info['menu paths'])) {
      $entity_names[] = $entity_type_name;
    }
  }

  foreach (entity_get_info() as $entity_type => $entity_info) {
    if (in_array($entity_type, $entity_names)) {
      foreach ($entity_info['bundles'] as $bundle_name => $bundle_info) {
        if (isset($bundle_info['admin'])) {
          $path = $bundle_info['admin']['path'];
          if (isset($bundle_info['admin']['bundle argument'])) {
            $bundle_arg = $bundle_info['admin']['bundle argument'];
          }
          else {
            $bundle_arg = $bundle_name;
          }

          $access = array(
            'access callback' => 'user_access',
            'access arguments' => array('administer layouts'),
          );

          $items["$path/layouts"] = array(
            'title' => 'Manage layouts',
            'page callback' => 'backdrop_get_form',
            'page arguments' => array('layout_entity_admin_form', $entity_type, $bundle_arg),
            'type' => MENU_LOCAL_TASK,
            'weight' => 2,
            'file' => 'layout.entity.admin.inc',
          ) + $access;
          $items["$path/layouts/add"] = array(
            'title' => 'Add layout',
            'title callback' => 'layout_entity_menu_title',
            'title arguments' => array($entity_type, $bundle_arg),
            'page callback' => 'backdrop_get_form',
            'page arguments' => array('layout_entity_admin_add_form', $entity_type, $bundle_arg),
            'file' => 'layout.entity.admin.inc',
            'type' => MENU_LOCAL_ACTION,
          ) + $access;
        }
      }
    }
  }

  return $items;
}

/**
 * Menu loader callback; Convert %layout_path placeholders to loaded objects.
 */
function layout_path_load($arg_value, $menu_item_name, $path_parts, $arg_position) {
  $menu_item = layout_menu_item_load($menu_item_name);
  $contexts = $menu_item->getContexts();
  $context_info = layout_get_context_info($contexts[$arg_position]->plugin);

  if (isset($context_info['load callback']) && function_exists($context_info['load callback'])) {
    return call_user_func_array($context_info['load callback'], array($arg_value));
  }

  // Pass-through the string argument if no load callback specified.
  return $arg_value;
}

/**
 * Create a menu item for Layout-provided pages.
 *
 * @param array $menu
 *   The configuration for this menu item as configured by the user.
 * @param $access_arguments
 *   The arguments for the menu system.
 * @param $page_arguments
 *   The page callback arguments for the menu system.
 * @param $load_arguments
 *   The magic loader arguments for the menu system.
 *
 * @return array
 *   The menu item array.
 */
function layout_page_menu_item(array $menu, array $access_arguments, array $page_arguments, array $load_arguments) {
  $item = array(
    'access callback' => 'layout_page_access',
    'access arguments' => $access_arguments,
    'page callback' => 'layout_page_callback',
    'page arguments' => $page_arguments,
    'load arguments' => $load_arguments,
    'file' => 'layout.pages.inc',
  );

  if (isset($menu['title'])) {
    $item['title'] = $menu['title'];
  }

  if (isset($menu['weight'])) {
    $item['weight'] = $menu['weight'];
  }

  if (empty($menu['type'])) {
    $menu['type'] = 'none';
  }

  switch ($menu['type']) {
    case 'normal':
      $item['type'] = MENU_NORMAL_ITEM;
      // Insert item into the proper menu.
      $item['menu_name'] = $menu['name'];
      break;
    case 'tab':
      $item['type'] = MENU_LOCAL_TASK;
      break;
    case 'action':
      $item['type'] = MENU_LOCAL_ACTION;
      break;
    case 'default tab':
      $item['type'] = MENU_DEFAULT_LOCAL_TASK;
      break;
    case 'none':
    default:
      $item['type'] = MENU_CALLBACK;
      break;
  }

  return $item;
}

/**
 * Menu title callback; Return the title for editing a layout.
 */
function layout_page_title(Layout $layout) {
  // Page titles are run through check_plain() before output, so no escaping
  // here is intentional. See backdrop_get_title().
  return $layout->title;
}

/**
 * Menu access callback; Check access for any Layout-provided page.
 */
function layout_page_access() {
  module_load_include('inc', 'layout', 'layout.pages');
  $args = func_get_args();
  return call_user_func_array('_layout_page_access', $args);
}

/**
 * Title callback: Returns a label for the action link to create bundle layouts.
 *
 * @param string $entity_type
 *   The entity type such as "node", "user", "taxonomy_term", etc.
 * @param string|stdClass $bundle_arg
 *   The bundle as a string or object. The object may be a TaxonomyVocabulary
 *   or stdClass (in the case of a node type).
 *
 * @return string
 *   The translated label used for the local actions.
 *
 * @see layout_menu()
 */
function layout_entity_menu_title($entity_type, $bundle_arg) {
  module_load_include('inc', 'layout', 'layout.entity.admin');
  $entity_info = entity_get_info($entity_type);
  $single_bundle = (count($entity_info['bundles']) == 1) && isset($entity_info['bundles'][$entity_type]);

  if (!$single_bundle) {
    $bundle_label = _layout_entity_bundle_label($entity_type, $bundle_arg);
    return t('Add @bundle_label layout', array('@bundle_label' => $bundle_label));
  }
  else {
    return t('Add @entity layout', array('@entity' => $entity_info['label']));
  }
}

/**
 * Suppress the layout.
 *
 * This function should be called from within another module's page callback
 * when the layout should not be displayed, that is, content only. This can be
 * useful for modules that implement popup pages or other special pages where
 * the default layout would be distracting.
 *
 * @param bool $suppress
 *   If set to TRUE, the layout will be suppressed.
 *
 * @return bool
 *   TRUE if the layout can be suppressed, FALSE otherwise.
 *
 * @since 1.21.0 Function added.
 */
function layout_suppress($suppress = NULL) {
  $suppression_static = &backdrop_static(__FUNCTION__, FALSE);

  if (isset($suppress)) {
    $suppression_static = $suppress;
  }

  return $suppression_static;
}

/**
 * Route handler callback; Execute the current route item or wrap in a layout.
 *
 * @param $router_item
 *   The menu router item for the page currently being loaded.
 *
 * @return
 *   The fully built HTML content for this page, which will be wrapped in
 *   page.tpl.php.
 *
 * @ingroup callbacks
 */
function layout_route_handler($router_item) {
  // If a different delivery callback is specified, we're probably not returning
  // HTML, and it definitely should not be wrapped in a layout. Call the default
  // route handler, and return its response directly. Do the same if requested
  // by layout_suppress().
  if (!backdrop_is_html() || !empty($router_item['delivery_callback']) || $router_item['page_callback'] === 'layout_page_callback' || layout_suppress()) {
    return menu_default_route_handler($router_item);
  }

  $selected_layout = layout_get_layout_by_path(NULL, $router_item);

  // Safety check that we don't show an admin layout to a user who cannot view
  // the admin theme. This may happen because the cached layout list does not
  // include a permissions check on the admin theme.
  if ($selected_layout->name === 'admin_default' && !user_access('view the administration theme')) {
    $selected_layout = layout_load('default');
  }

  // Special handling for 404 and 403 pages to render in admin theme. The
  // current path will be the 404/403 system path, and we need to check the
  // original path, which is stored in "destination" by
  // backdrop_deliver_html_page().
  if (in_array(backdrop_get_http_header('Status'), array(
    '404 Not Found',
    '403 Forbidden',
  )) && user_access('view the administration theme')) {
    if (isset($_GET['destination']) && path_is_admin($_GET['destination'])) {
      $selected_layout = layout_load('admin_default');
    }
  }

  if ($selected_layout) {
    // Render the layout.
    $renderer = layout_create_renderer($selected_layout->renderer_name, $selected_layout);

    if ($selected_layout->isDefault()) {
      $renderer->ensurePageContentBlock();
    }

    return $renderer->render();
  }

  // Fallback code if even the expected default layout cannot be found.
  return menu_default_route_handler($router_item);
}

/**
 * Implements hook_theme()
 */
function layout_theme() {
  $base = array(
    'file' => 'layout.theme.inc',
  );

  $items = array(
    'layout' => array(
      'variables' => array(
        'content' => NULL,
        'settings' => NULL,
        'layout' => NULL,
        'layout_template_info' => NULL,
        // @todo: Remove layout_info in favour of layout_template_info in 2.x.
        'layout_info' => NULL,
        'renderer' => NULL,
        'attributes' => array(),
        'admin' => FALSE,
      ),
      'template' => 'templates/layout',
    ) + $base,
    'layout_reorder_layouts' => array(
      'render element' => 'element',
    ) + $base,
    'layout_content_form' => array(
      'template' => 'templates/layout-content-form',
      'render element' => 'form',
    ) + $base,
    'layout_hero_background_image' => array(
      'render element' => 'element',
    ) + $base,
    'layout_info' => array(
      'variables' => array('layout' => NULL),
    ) + $base,
    'layout_condition_info' => array(
      'variables' => array(
        'layout' => NULL,
        'show_empty' => TRUE,
      ),
    ) + $base,
    'layout_template_option' => array(
      'variables' => array('template_info' => NULL),
    ) + $base,
    'layout_template_info' => array(
      'variables' => array('template_info' => NULL),
    ) + $base,
    'layout_flexible_template_style_option' => array(
      'variables' => array('row_style' => NULL),
    ) + $base,
    'layout_menu_item_arguments_table' => array(
      'render element' => 'element',
    ) + $base,
    'layout_settings_context_table' => array(
      'render element' => 'element',
    ) + $base,
    'layout_action_links' => array(
      'render element' => 'element',
    ) + $base,
    'layout_conditions' => array(
      'render element' => 'element',
    ) + $base,
    'layout_region_inner' => array(
      'variables' => array(
        'blocks' => array(),
        'tag' => '',
        'classes' => array(),
        'attributes' => array(),
      ),
    ) + $base,
  );

  // Register all layout templates.
  $layout_templates = layout_get_layout_template_info();

  foreach ($layout_templates as $template) {
    if (!empty($template['template'])) {
      $theme_key = str_replace('-', '_', $template['template']);
      $items[$theme_key] = array(
        'variables' => array(
          'content' => NULL,
          'settings' => NULL,
          'layout' => NULL,
          'layout_template_info' => NULL,
          'renderer' => NULL,
          'attributes' => array(),
          'admin' => FALSE,
          // Deprecated. Renamed to layout_template_info.
          // @todo: Remove in 2.x.
          'layout_info' => NULL,
        ),
        'template' => $template['template'],
        'path' => $template['path'],
        'base hook' => 'layout',
      );

      if (isset($template['file'])) {
        $items[$theme_key]['file'] = $template['file'];
      }
    }
  }

  // Register all styles.
  $styles = _layout_get_all_info('layout_style');

  foreach ($styles as $style) {
    if (!empty($style['block theme'])) {
      $items[$style['block theme']] = array(
        'variables' => array(
          'content' => NULL,
          'layout' => NULL,
          'block' => NULL,
          'style' => NULL,
          'settings' => array(),
          'attributes' => array(),
        ),
      );

      if (isset($style['file'])) {
        $items[$style['block theme']]['file'] = $style['file'];
      }

      if (isset($style['path'])) {
        $items[$style['block theme']]['path'] = $style['path'];
      }

      if (isset($style['template'])) {
        $items[$style['block theme']]['template'] = $style['template'];
      }
    }

    if (!empty($style['hook theme'])) {
      if (is_array($style['hook theme'])) {
        $items += $style['hook theme'];
      }
      elseif (function_exists($style['hook theme'])) {
        $style['hook theme']($items, $style);
      }
    }
  }

  return $items;
}

/**
 * Implements hook_permission().
 */
function layout_permission() {
  return array(
    'administer layouts' => array(
      'title' => t('Administer Layouts'),
      'description' => t('Create and modify layouts and blocks.'),
      'restrict access' => TRUE,
      'warning' => t('Change the access/visibility of menu items, layouts and blocks.'),
    ),
    'administer flexible templates' => array(
      'title' => t('Administer Flexible Templates'),
      'description' => t('Create, configure and delete flexible layout templates.'),
      'restrict access' => TRUE,
      'warning' => t('Manage all aspects of flexible layout templates, including deleting them.'),
    ),
  );
}

/**
 * Implements hook_config_info().
 */
function layout_config_info() {
  $prefixes['layout.settings'] = array(
    'label' => t('Layout settings'),
    'group' => t('Configuration'),
  );

  $prefixes['layout.layout'] = array(
    'name_key' => 'name',
    'label_key' => 'title',
    'group' => t('Layouts'),
  );

  $prefixes['layout.menu_item'] = array(
    'name_key' => 'name',
    'label_key' => 'path',
    'group' => t('Layout menu items'),
  );

  $prefixes['layout.flexible'] = array(
    'name_key' => 'name',
    'label_key' => 'title',
    'group' => t('Flexible layout templates'),
  );

  return $prefixes;
}

/**
 * Implements hook_library_info().
 */
function layout_library_info() {
  $path = backdrop_get_path('module', 'layout');

  $libraries['bootstrap4-gs'] = array(
    'title' => 'Bootstrap4 Grid System',
    'website' => 'http://v4-alpha.getbootstrap.com/layout/grid/',
    'version' => BACKDROP_VERSION,
    'css' => array(
      $path . '/css/grid-flexbox.css' => array(),
    ),
    'js' => array(
      $path . '/js/grid-fallback.js' => array(),
    ),
  );

  return $libraries;
}

/**
 * Implements hook_layout_api().
 */
function layout_layout_api() {
  return array(
    'file' => 'includes/layout.layout.inc',
  );
}

/**
 * Implements hook_block_info().
 */
function layout_block_info() {
  $blocks = array();
  $blocks['custom_block'] = array(
    'info' => t('Custom block'),
    'description' => t('A basic block for adding custom text.'),
    'class' => 'BlockText',
  );

  $blocks['hero'] = array(
    'info' => t('Hero block'),
    'description' => t('A hero block often consists of text over a background image, though either are optional.'),
    'class' => 'BlockHero',
  );

  return $blocks;
}

/**
 * Implements hook_autoload_info().
 */
function layout_autoload_info() {
  return array(
    'Block' => 'includes/block.class.inc',
    'BlockBroken' => 'includes/block.class.inc',
    'BlockHero' => 'includes/block.hero.inc',
    'BlockLegacy' => 'includes/block_legacy.class.inc',
    'BlockText' => 'includes/block.text.inc',
    'Layout' => 'includes/layout.class.inc',
    'LayoutFlexibleTemplate' => 'includes/layout_flexible.class.inc',
    'LayoutHandler' => 'includes/layout_handler.class.inc',
    'LayoutHandlerBroken' => 'includes/layout_handler.class.inc',
    'LayoutMenuItem' => 'includes/layout_menu_item.class.inc',

    // Exceptions.
    'LayoutException' => 'includes/layout.exceptions.inc',
    'LayoutMissingException' => 'includes/layout.exceptions.inc',
    'LayoutSaveException' => 'includes/layout.exceptions.inc',

    // Context handlers.
    'EntityLayoutContext' => 'plugins/context/entity_layout_context_handler.inc',
    'LayoutContextBroken' => 'plugins/context/layout_context.inc',
    'LayoutOverridesPathContext' => 'plugins/context/layout_context.inc',
    'LayoutStringContext' => 'plugins/context/layout_context.inc',
    'LayoutContext' => 'plugins/context/layout_context.inc',

    // Access handlers.
    'EntityBundleLayoutAccess' => 'plugins/access/entity_bundle_layout_access.inc',
    'EntityIDLayoutAccess' => 'plugins/access/entity_id_layout_access.inc',
    'FrontLayoutAccess' => 'plugins/access/front_layout_access.inc',
    'HttpResponseCodeLayoutAccess' => 'plugins/access/http_response_code_layout_access.inc',
    'LanguageLayoutAccess' => 'plugins/access/language_layout_access.inc',
    'LayoutAccess' => 'plugins/access/layout_access.inc',
    'LayoutAccessBroken' => 'plugins/access/layout_access.inc',
    'LayoutAccessNegatable' => 'plugins/access/layout_access.inc',
    'PathLayoutAccess' => 'plugins/access/path_layout_access.inc',
    'UserCompareLayoutAccess' => 'plugins/access/user_compare_layout_access.inc',
    'UserPermissionLayoutAccess' => 'plugins/access/user_permission_layout_access.inc',
    'UserRoleLayoutAccess' => 'plugins/access/user_role_layout_access.inc',

    // Renderer handlers.
    'LayoutRendererEditor' => 'plugins/renderers/layout_renderer_editor.inc',
    'LayoutRendererFlexible' => 'plugins/renderers/layout_renderer_flexible.inc',
    'LayoutRendererStandard' => 'plugins/renderers/layout_renderer_standard.inc',

    // Styles.
    'LayoutStyle' => 'plugins/styles/layout_style_default.inc',
    'LayoutStyleDynamic' => 'plugins/styles/layout_style_dynamic.inc',

    // Relationships.
    'LayoutRelationship' => 'plugins/relationships/layout_relationship.inc',
    'LayoutRelationshipAuthorFromNode' => 'plugins/relationships/author_from_node.inc',
    'LayoutRelationshipBroken' => 'plugins/relationships/layout_relationship.inc',
  );
}

/**
 * Implements hook_contextual_links_view_alter()
 */
function layout_contextual_links_view_alter(&$element, $items) {
  // Convert the link to manage blocks to use a shortened URL that lands the
  // user on the overall layout edit screen with a modal opened, instead of the
  // path to the block edit page itself.
  $links = &$element['#links'];

  if (isset($links['layout-configure-redirect-'])) {
    if ($position = strpos($links['layout-configure-redirect-']['href'], '/configure-redirect')) {
      $last_slash = strrpos($links['layout-configure-redirect-']['href'], '/');
      $uuid = substr($links['layout-configure-redirect-']['href'], $last_slash + 1);
      $links['layout-configure-redirect-']['fragment'] = 'configure-block:' . $uuid;
    }
  }
}

/**
 * Load an individual layout.
 *
 * @param string $layout_name
 *   The layout machine name to load.
 * @param bool $skip_menu_items
 *   Flag to skip the attempted loading of menu items for the loaded layouts.
 *   This should be set to TRUE if loading layouts that definitely do not have
 *   menu items associated with them, for example the default layouts or a
 *   layout that overrides an existing menu path.
 *
 * @return Layout|boolean
 */
function layout_load($layout_name, $skip_menu_items = NULL) {
  // Skip menu item loading for default layouts, as we know they do not have
  // an associated menu item.
  if (is_null($skip_menu_items)) {
    $skip_menu_items = in_array($layout_name, array('default', 'admin_default'));
  }

  $layouts = layout_load_multiple(array($layout_name), $skip_menu_items);
  return $layouts[$layout_name];
}

/**
 * Load multiple layouts based on a particular criteria.
 *
 * @param array $layout_names
 *   The names of the layouts to be loaded.
 * @param bool $skip_menu_items
 *   Flag to skip the attempted loading of menu items for the loaded layouts.
 *   This should be set to TRUE if loading layouts that definitely do not have
 *   menu items associated with them, for example the default layouts or a
 *   layout that overrides an existing menu path.
 *
 * @return Layout[]
 *   An array of Layout object instances.
 */
function layout_load_multiple($layout_names, $skip_menu_items = FALSE) {
  $loaded_layouts = &backdrop_static(__FUNCTION__, array());

  $layouts_to_load = array();
  foreach ($layout_names as $layout_name) {
    if (!isset($loaded_layouts[$layout_name])) {
      $layouts_to_load[] = $layout_name;
    }
  }

  if ($layouts_to_load) {
    $menu_items = layout_menu_item_load_multiple($layout_names);

    // Cache the raw config files once read.
    $configs = layout_get_all_configs('layout');

    // Create the layout instances and associate the menu items with each.
    foreach ($layouts_to_load as $layout_name) {
      if (isset($configs[$layout_name])) {
        $layout_data = $configs[$layout_name];
        $loaded_layouts[$layout_name] = new Layout($layout_data);

        // Associate the applicable menu item.
        if (isset($layout_data['path']) && !$skip_menu_items) {
          // Most of the time, layouts will be loaded as a group, including the
          // layout that owns the menu item.
          if (isset($menu_items[$layout_data['path']])) {
            $loaded_layouts[$layout_name]->menu_item = $menu_items[$layout_data['path']];
          }
          // In the situation that a layout is loaded separately of its menu
          // item owner, load the menu item by path.
          elseif ($menu_item = layout_menu_item_load_multiple_by_path($layout_data['path'])) {
            $loaded_layouts[$layout_name]->menu_item = $menu_item;
          }
        }
      }
    }
  }

  // Load menu items for additional paths.
  foreach ($loaded_layouts as $layout_name => $loaded_layout) {
    if (!empty($loaded_layout->additional_paths) && !$skip_menu_items) {
      foreach ($loaded_layout->additional_paths as $additional_path) {
        if (isset($menu_items[$additional_path])) {
          $loaded_layouts[$layout_name]->additional_menu_items[$additional_path] = $menu_items[$additional_path];
        }
        elseif ($additional_path_menu_item = layout_menu_item_load_multiple_by_path($additional_path)) {
          $loaded_layouts[$layout_name]->additional_menu_items[$additional_path] = $additional_path_menu_item;
        }
      }
    }
  }

  // Return the requested layouts.
  $layouts = array();

  foreach ($layout_names as $layout_name) {
    if (isset($loaded_layouts[$layout_name])) {
      $layouts[$layout_name] = $loaded_layouts[$layout_name];
    }
    else {
      $layouts[$layout_name] = FALSE;
    }
  }

  return $layouts;
}

/**
 * Load all layouts for a given router item and allow other modules to alter
 * them and/or set their contexts.
 *
 * @param array $router_item
 *   The fully built menu router item, e.g., what is returned by menu_get_item().
 * @param bool $skip_menu_items
 *   Flag to skip the attempted loading of menu items for the loaded layouts.
 *
 * @return Layout[]
 *   An array of load Layout object instances.
 */
function layout_load_multiple_by_router_item($router_item, $skip_menu_items = NULL) {
  $href = $router_item['href'];
  $layouts_by_item = &backdrop_static(__FUNCTION__, array());

  if (isset($layouts_by_item[$href])) {
    return $layouts_by_item[$href];
  }

  $layouts = layout_load_multiple_by_path($router_item['path'], $skip_menu_items);
  backdrop_alter('layout_load_by_router_item', $layouts, $router_item);
  $layouts_by_item[$href] = $layouts;
  return $layouts;
}

/**
 * Load all layouts at a given path.
 *
 * This function does not invoke hook_layout_load_by_router_item_alter(). In
 * general, developers should use layout_load_multiple_by_router_item() rather
 * than layout_load_multiple_by_path() to allow client modules to alter the
 * layouts and only call this function in situations where client alteration is
 * not desired and/or the router item is not available. Examples where this
 * might be needed:
 * - Inside a hook_menu() implementation (see dashboard_menu()).
 * - Inside a hook_layout_load_by_router_item_alter() implementation (see
 *   node_layout_load_by_router_item_alter()).
 *
 * @param string $path
 *   The menu routing path, with all placeholders represented by "%" symbols.
 * @param bool $skip_menu_items
 *   Flag to skip the attempted loading of menu items for the loaded layouts.
 *
 * @return Layout[]
 *   An array of load Layout object instances.
 *
 * @see dashboard_menu()
 * @see node_layout_load_by_router_item_alter()
 */
function layout_load_multiple_by_path($path, $skip_menu_items = NULL) {
  if ($cache = cache('layout_path')->get($path)) {
    $layouts = $cache->data;

    // Populate these cached layouts into layout_load_multiple() to optimize
    // any future calls to it.
    $static_cache = &backdrop_static('layout_load_multiple', array());
    $static_cache = array_merge($layouts, $static_cache);
  }
  else {
    $layout_names = layout_get_path_layout_names($path);

    if (empty($layout_names)) {
      // Skip loading menu items for the default layouts.
      if (is_null($skip_menu_items)) {
        $skip_menu_items = TRUE;
      }

      if (path_is_admin($path)) {
        $layout_names[] = 'admin_default';
      }
      else {
        $layout_names[] = 'default';
      }
    }

    $layouts = layout_load_multiple($layout_names, $skip_menu_items);
    cache('layout_path')->set($path, $layouts);
  }

  return $layouts;
}

/**
 * Return an array of all layouts as fully loaded Layout objects.
 *
 * Note that this operation can be very expensive and its use is discouraged.
 * Use layout_load_multiple() to load specific layouts.
 *
 * @return Layout[]
 *   An array of Layout object instances.
 */
function layout_load_all() {
  $configs = layout_get_all_configs('layout');
  $layout_names = array_keys($configs);
  return layout_load_multiple($layout_names);
}

/**
 * Load an individual Layout menu item.
 *
 * @return LayoutMenuItem|boolean
 */
function layout_menu_item_load($menu_item_name) {
  $menu_items = layout_menu_item_load_multiple(array($menu_item_name));

  // Returned menu items are by path, so return the first item if it exists.
  if ($path = key($menu_items)) {
    return $menu_items[$path];
  }
  else {
    return FALSE;
  }
}

/**
 * Load menu items by name.
 *
 * @param array $menu_item_names
 *   An array of menu item names, if left empty, all Layout menu items will
 *   be returned.
 *
 * @return array
 *   An array of loaded LayoutMenuItem instances, keyed by the layout menu item
 *   path.
 */
function layout_menu_item_load_multiple($menu_item_names = NULL) {
  $loaded_menu_items = &backdrop_static(__FUNCTION__, array());

  $menu_items_to_load = array();
  foreach ($menu_item_names as $menu_item_name) {
    if (!isset($loaded_menu_items[$menu_item_name])) {
      $menu_items_to_load[] = $menu_item_name;
    }
  }

  if ($menu_items_to_load) {
    $configs = layout_get_all_configs('menu_item');
    foreach ($menu_items_to_load as $menu_item_name) {
      if (isset($configs[$menu_item_name])) {
        $loaded_menu_items[$menu_item_name] = new LayoutMenuItem($configs[$menu_item_name]);
      }
    }
  }

  // Return the requested menu items.
  $menu_items = array();
  foreach ($menu_item_names as $menu_item_name) {
    if (isset($loaded_menu_items[$menu_item_name])) {
      $path = $loaded_menu_items[$menu_item_name]->path;
      $menu_items[$path] = $loaded_menu_items[$menu_item_name];
    }
  }

  return $menu_items;
}

/**
 * Load an individual Layout menu item based on its path.
 */
function layout_menu_item_load_multiple_by_path($path) {
  $configs = layout_get_all_configs('menu_item');
  foreach ($configs as $menu_item_name => $config) {
    if ($config['path'] === $path) {
      return layout_menu_item_load($menu_item_name);
    }
  }

  return FALSE;
}

/**
 * Return an array of all menu items as fully loaded LayoutMenuItem objects.
 *
 * Note this operation may be expensive. It should only be called in areas where
 * the results will be cached, e.g. on menu rebuild.
 */
function layout_menu_item_load_all() {
  $configs = layout_get_all_configs('menu_item');
  $menu_item_names = array_keys($configs);
  return layout_menu_item_load_multiple($menu_item_names);
}

/**
 * Read all configuration files from disk of a particular layout type.
 *
 * This method provides basic caching around Layout's config files.
 *
 * @param $type
 *   Either "layout" or "menu_item".
 *
 * @return array
 *   An array of all configs for the specified type.
 */
function layout_get_all_configs($type) {
  // Cache the raw config files once read.
  if ($cache = cache()->get('layout:' . $type . ':config')) {
    $configs = $cache->data;
  }
  else {
    $configs = array();

    $config_names = config_get_names_with_prefix('layout.' . $type . '.');
    foreach ($config_names as $config_file) {
      $config = config($config_file);
      $data = $config->get();
      $data += array(
        'weight' => 0,
      );
      $configs[$data['name']] = $data;
    }

    // Sort the configs by path and weight.
    backdrop_sort($configs, array(
      'path' => SORT_STRING,
      'weight' => SORT_NUMERIC,
    ));

    // Put default layouts at the bottom.
    if ($type === 'layout') {
      $default = $configs['default'];
      $admin_default = $configs['admin_default'];
      unset($configs['default']);
      unset($configs['admin_default']);
      $configs['default'] = $default;
      $configs['admin_default'] = $admin_default;
    }

    cache()->set('layout:' . $type . ':config', $configs);
  }

  return $configs;
}

/**
 * Get a list of layouts that share a particular path.
 */
function layout_get_path_layout_names($path) {
  $path_map = &backdrop_static(__FUNCTION__, array());

  if (empty($path_map)) {
    $configs = layout_get_all_configs('layout');
    foreach ($configs as $layout_name => $config) {
      if (isset($config['path'])) {
        $path_map[$config['path']][] = $layout_name;
      }
      if (isset($config['settings']['additional_paths'])) {
        foreach ($config['settings']['additional_paths'] as $additional_path) {
          if (!empty($additional_path)) {
            $path_map[$additional_path][] = $layout_name;
          }
        }
      }
    }
  }

  return isset($path_map[$path]) ? $path_map[$path] : array();
}

/**
 * Check if a path is provided by Layout module, as in a custom layout path.
 *
 * @return
 *   Boolean TRUE if Layout module provides a path, FALSE if another module
 *   specified the path, or NULL if a path does not exist in the system.
 */
function layout_provides_path($path) {
  if (empty($path)) {
    return FALSE;
  }

  $result = db_query('SELECT * FROM {menu_router} WHERE path = :path', array(':path' => $path));
  $return = NULL;

  // If any page callback exists at this path, allow it to trump custom layouts.
  foreach ($result as $router) {
    if ($router->page_callback == 'layout_page_callback') {
      $return = TRUE;
    }
    else {
      $return = FALSE;
      break;
    }
  }

  return $return;
}

/**
 * Get the layout which is active based on a path or router item.
 *
 * This may also be used to get the current layout on a page if no parameters
 * are passed. In which case the current path will be used.
 *
 * @param string $path
 *   The menu routing path, with all placeholders represented by "%" symbols.
 * @param array $router_item
 *   The menu router item for the page currently being loaded.
 *   The $path parameter will be ignored if $router_item is specified.
 * @param bool $is_layout_page
 *   Flag that says whether this is being called from the page callback for a
 *   layout-provided page.
 *
 * @return Layout
 *   The Layout object for the specified path.
 *
 * @since 1.4.0
 */
function layout_get_layout_by_path($path = NULL, $router_item = NULL, $is_layout_page = FALSE) {
  if (!isset($router_item)) {
    $router_item = menu_get_item($path);
  }

  // Use the static cache, but keyed on the normal path (such as node/1), rather
  // than the system path (such as node/%), since client modules might serve up
  // different layouts for the same system path.
  $href = $router_item['href'];
  $layouts_by_path = &backdrop_static(__FUNCTION__, array());
  if (isset($layouts_by_path[$href])) {
    return $layouts_by_path[$href];
  }

  $layouts = layout_load_multiple_by_router_item($router_item, !$is_layout_page);
  $selected_layout = NULL;
  foreach ($layouts as $layout) {
    // Contexts must have their data set before the layout's access may be
    // checked.
    $menu_contexts = $layout->getContexts(LayoutContext::USAGE_TYPE_MENU);
    foreach ($menu_contexts as $menu_context) {
      $menu_context->setDataFromRouter($router_item);
    }
    backdrop_static_reset('Layout::getContexts');

    if (!$layout->disabled && $layout->checkAccess()) {
      $selected_layout = $layout;
      break;
    }
  }

  if (!$is_layout_page) {
    // If no layout matches at the path, use a default layout.
    if (!$selected_layout) {
      if (path_is_admin($router_item['path']) && user_access('view the administration theme')) {
        $selected_layout = layout_load('admin_default');
      }
      else {
        $selected_layout = layout_load('default');
      }
    }
  }

  $layouts_by_path[$href] = $selected_layout;
  return $selected_layout;
}

/**
 * Implements hook_flush_caches().
 */
function layout_flush_caches() {
  return array('layout_path');
}

/**
 * Reset all caches provided by Layout module.
 */
function layout_reset_caches() {
  cache()->delete('layout:layout:config');
  cache()->delete('layout:menu_item:config');
  cache()->delete('layout_template_info:layout');
  cache()->delete('layout_template_info:flexible');
  cache('layout_path')->flush();

  backdrop_static_reset('layout_load_multiple');
  backdrop_static_reset('layout_menu_item_load_multiple');
  backdrop_static_reset('layout_get_path_layout_names');
  backdrop_static_reset('layout_get_layout_template_info:layout');
  backdrop_static_reset('layout_get_layout_template_info:flexible');
  backdrop_static_reset('layout_get_block_info');
  backdrop_static_reset('layout_get_layout_tempstore');
  backdrop_static_reset('_layout_include_files');
  backdrop_static_reset('_layout_get_all_info');
}

/**
 * Load all include files for modules that implement hook_layout_api().
 */
function _layout_include_files() {
  $included = &backdrop_static(__FUNCTION__, FALSE);
  if (!$included) {
    foreach (module_implements('layout_api') as $module) {
      $function = $module . '_layout_api';
      $api_info = $function();
      if (isset($api_info['file'])) {
        include_once(BACKDROP_ROOT . '/' . backdrop_get_path('module', $module) . '/' . $api_info['file']);
      }
    }
    $included = TRUE;
  }
}

/**
 * Load layout-related information from modules.
 */
function _layout_get_all_info($data_type, $init = array()) {
  $all_info = &backdrop_static(__FUNCTION__);

  if (!isset($all_info[$data_type])) {
    _layout_include_files();
    $all_info[$data_type] = $init;

    foreach (module_implements($data_type . '_info') as $module) {
      $function = $module . '_' . $data_type . '_info';
      // A module implements deprecated hook_layout_info(), which has been
      // renamed in 1.30.0.
      if ($data_type == 'layout') {
        $link = l(t('Change record: @hook_old has been renamed to @hook_new.', array(
          '@hook_old' => 'hook_layout_info()',
          '@hook_new' => 'hook_layout_template_info()',
        )), 'https://docs.backdropcms.org/change-records/hook_layout_info-renamed-to-hook_layout_template_info');
        // We can not use watchdog_deprecated_function() here, as its message
        // would misleadingly point to this function instead of the actual hook
        // implementation.
        $placeholders = array(
          '%module' => $module,
          '%hook' => 'hook_layout_info()',
          '%function' => $function . '()',
        );
        watchdog('layout', 'Module %module implements deprecated %hook in %function.', $placeholders, WATCHDOG_DEPRECATED, $link);
      }
      $data = $function();
      $module_path = backdrop_get_path('module', $module);

      foreach ($data as $key => $info) {
        $info['module'] = $module;
        $info['name'] = $key;

        if (isset($info['path'])) {
          $info['path'] = $module_path . '/' . $info['path'];
        }
        else {
          $info['path'] = $module_path;
        }
        $all_info[$data_type][$key] = $info;
      }
    }
  }

  return $all_info[$data_type];
}

/**
 * Load the information of either a single layout template or all available
 * layout templates.
 *
 * @param string $template_name
 *   Optionally specify a name of a single layout template, e.g. "boxton" or
 *   "simmons". If no layout template name is specified, information for all
 *   layout templates will be returned.
 *
 * @param boolean $rebuild
 *   Whether the list of layout template info needs to be rebuilt (see
 *   https://github.com/backdrop/backdrop-issues/issues/984). The rebuild is
 *   required only on specific cases, so this defaults to FALSE. That way, the
 *   rest of the times the layout cache is used (when available) for performance
 *   reasons.
 *
 * @return array|boolean
 *   The layout template information, as returned by either a stand-alone
 *   template .info file, or through a module's hook_layout_template_info().
 *
 * @see hook_layout_template_info()
 * @see hook_layout_info()
 */
function layout_get_layout_template_info($template_name = NULL, $rebuild = FALSE, $layout_template_type = 'layout') {
  _layout_standardize_template_type($layout_template_type);
  $info = &backdrop_static(__FUNCTION__ . ':' . $layout_template_type);

  // Try getting a cached list of layout info.
  if (!isset($info) && !$rebuild) {
    $cache = cache('cache')->get('layout_template_info:' . $layout_template_type);

    if ($cache && $cache->data) {
      $info = $cache->data;
    }
  }

  // Rebuild the list of layout info.
  if (!isset($info) || $rebuild) {
    $init = array();
    if ($layout_template_type == 'layout') {
      $files = backdrop_system_listing('/^' . BACKDROP_PHP_FUNCTION_PATTERN . '\.info$/', 'layouts', 'name', 0);

      foreach ($files as $name => $file) {
        $init[$name] = backdrop_parse_info_file($file->uri);

        // Skip modules or themes that have been placed in the wrong directory.
        if (isset($init[$name]['type']) && $init[$name]['type'] != 'layout') {
          unset($init[$name]);
          continue;
        }

        $init[$name]['path'] = dirname($file->uri);
        $init[$name]['title'] = $init[$name]['name'];
        $init[$name]['name'] = $name;
      }
      $info = _layout_get_all_info('layout_template', $init);
      // Account for implementations of the deprecated hook_layout_info().
      $info = _layout_get_all_info('layout', $info);
    }
    else {
      $info = layout_layout_template_info($layout_template_type);
    }

    // Populate defaults.
    foreach ($info as $name => $layout_template_info) {
      $info[$name] += array(
        'name' => $name,
        'hidden' => FALSE,
        'preview' => 'preview.png',
        'default region' => 'content',
        'is_full_page' => TRUE,
        'layout_template_type' => 'layout',
        'stylesheets' => array(
          'all' => array(str_replace('_', '-', $name) . '.css'),
        ),
      );
      if (isset($layout_template_info['path']) && !isset($info[$name]['template'])) {
        $template_path = BACKDROP_ROOT . '/' . $layout_template_info['path'] . '/layout--' . str_replace('_', '-', $name) . '.tpl.php';

        if (is_file($template_path)) {
          $info[$name]['template'] = 'layout--' . str_replace('_', '-', $name);
        }
      }
    }

    // Sort the available layouts by display name.
    backdrop_sort($info, array('title' => SORT_STRING));

    cache('cache')->set('layout_template_info:' . $layout_template_type, $info);
  }

  if ($template_name) {
    if (isset($info[$template_name])) {
      return $info[$template_name];
    }
    else {
      return FALSE;
    }
  }
  else {
    return $info;
  }
}

/**
 * Load the layout template information for a single layout template name.
 *
 * Duplicates the function layout_get_layout_template_info() to maintain
 * compatibility. Should not be used in new code.
 *
 * @param string $layout_name
 *   The name of the layout template, e.g. "one_column" or
 *   "three_three_four_column". If no layout template is specified, all layout
 *   info will be returned.
 *
 * @return array|boolean
 *   The layout template information, as returned by either a stand-alone
 *   template .info file, or through a module's hook_layout_template_info().
 *
 * @deprecated since 1.4.0
 * @see layout_get_layout_template_info()
 */
function layout_get_layout_info($layout_name = NULL) {
  return layout_get_layout_template_info($layout_name);
}

/**
 * Load all layout context information from modules.
 *
 * @param string $plugin_name
 *   The name of the plugin.
 *
 * @return array
 */
function layout_get_context_info($plugin_name) {
  $info = _layout_get_all_info('layout_context');

  return isset($info[$plugin_name]) ? $info[$plugin_name] : FALSE;
}

/**
 * Fetch all relevant relationships.
 *
 * Relevant relationships are any relationship that can be created based upon
 * the list of existing contexts. For example, the 'node author' relationship
 * is relevant if there is a 'node' context, but makes no sense if there is
 * not one.
 *
 * @param $contexts
 *   An array of contexts used to figure out which relationships are relevant.
 *
 * @return
 *   An array of relationship keys that are relevant for the given set of
 *   contexts.
 */
function layout_relationships_get_relevant_info($contexts) {
  $relevant = array();
  $relationships = _layout_get_all_info('layout_relationship');

  foreach ($contexts as $context) {
    // Go through each relationship.
    foreach ($relationships as $rid => $relationship) {
      $handler = layout_create_handler('layout_relationship', $rid);
      if ($children = $handler->getChildren($rid)) {
        foreach ($children as $child_rid => $child) {
          if ($child['context'] == $context->plugin) {
            $relevant[$child_rid] = $child;
          }
        }
      }
      else {
        if ($relationship['context'] == $context->plugin) {
          $relevant[$rid . ':relationship'] = $relationship;
        }
      }
    }
  }

  return $relevant;
}

/**
 * Load all layout relationship information from modules.
 *
 * @return array
 */
function layout_get_relationship_info($plugin_name) {
  $info = _layout_get_all_info('layout_relationship');
  return isset($info[$plugin_name]) ? $info[$plugin_name] : FALSE;
}

/**
 * Load all layout access information from modules.
 *
 * @return array
 */
function layout_get_access_info($plugin_name) {
  $info = _layout_get_all_info('layout_access');
  return isset($info[$plugin_name]) ? $info[$plugin_name] : FALSE;
}

/**
 * Load all layout renderer information from modules.
 *
 * @return array
 */
function layout_get_renderer_info($plugin_name) {
  $info = _layout_get_all_info('layout_renderer');
  return isset($info[$plugin_name]) ? $info[$plugin_name] : FALSE;
}

/**
 * Load all layout style information from modules.
 */
function layout_get_style_info($plugin_name) {
  $info = _layout_get_all_info('layout_style');
  return isset($info[$plugin_name]) ? $info[$plugin_name] : FALSE;
}

/**
 * Get information about all blocks or just a single one.
 *
 * @param $block_module
 *   The name of a module providing the desired block.
 * @param $block_delta
 *   The key of the block within that module.
 *
 * @return array|FALSE
 *   The information from hook_block_info() for the requests block(s).
 */
function layout_get_block_info($block_module = NULL, $block_delta = NULL) {
  $block_info = &backdrop_static(__FUNCTION__, array(
    'all' => NULL, // Set TRUE when block info for all modules has been loaded.
    'modules' => array(), // The actual list of stored block info, per module.
  ));

  if (isset($block_module)) {
    $modules = array($block_module);
  }
  elseif (!isset($block_info['all'])) {
    $modules = module_implements('block_info');
    $block_info['all'] = TRUE;
  }
  else {
    $modules = array();
  }

  // Load each module's block info that is required.
  $new_block_info = array();
  foreach ($modules as $module) {
    if (!isset($block_info['modules'][$module])) {
      $new_block_info[$module] = module_invoke($module, 'block_info');
    }
  }

  // Alter and merge the collection of new blocks.
  if (!empty($new_block_info)) {
    backdrop_alter('block_info', $new_block_info);
    $block_info['modules'] = array_merge($block_info['modules'], $new_block_info);
  }

  // Return partial or full results based on the requested properties.
  if (isset($block_module) && isset($block_delta)) {
    if (isset($block_info['modules'][$block_module][$block_delta])) {
      return $block_info['modules'][$block_module][$block_delta];
    }
    else {
      return FALSE;
    }
  }
  elseif (isset($block_module)) {
    if (isset($block_info['modules'][$block_module])) {
      return $block_info['modules'][$block_module];
    }
    else {
      return FALSE;
    }
  }

  return $block_info['modules'];
}

/**
 * Helper function to get a handler class name based on the plugin name.
 */
function layout_get_handler_name($plugin_type, $plugin_name) {
  // Block "plugins" for Layouts are wrappers around the generic block system.
  $broken_class = NULL;

  if ($plugin_type === 'block') {
    $parts = explode(':', $plugin_name);
    list($module, $delta) = $parts;
    $info = layout_get_block_info($module, $delta);

    if ($info) {
      if (isset($info['class'])) {
        $class_name = $info['class'];
      }
      else {
        $class_name = 'BlockLegacy';
      }
      // Field blocks use the field name as the third part of the plugin name.
      // If the field no longer exists, return a broken block.
      if ($delta == 'field_block' && isset($parts[2])) {
        $field_name = $parts[2];
        $available_fields = field_get_block_list();

        if (empty($available_fields[$field_name])) {
          $class_name = 'BlockBroken';
        }
      }
    }
    else {
      $class_name = 'BlockBroken';
    }
  }
  else {
    $info = _layout_get_all_info($plugin_type);

    switch ($plugin_type) {
      case 'layout_access':
        $broken_class = 'LayoutAccessBroken';
        break;
      case 'layout_context':
        $broken_class = 'LayoutContextBroken';
        break;
      case 'layout_relationship':
        $broken_class = 'LayoutRelationshipBroken';
        break;
      case 'layout_style':
        $broken_class = 'LayoutStyle';
        break;
    }

    if (isset($info[$plugin_name]['class']) && class_exists($info[$plugin_name]['class'])) {
      $class_name = $info[$plugin_name]['class'];
    }
    else {
      $class_name = $broken_class;
    }
  }

  return $class_name;
}

/**
 * Helper function to instantiate handlers when loading from config.
 *
 * @param string $plugin_type
 *   The type of plugin being loaded, i.e. 'context', 'access', etc.
 * @param string $plugin_name
 *   The name of the plugin, as keyed by that plugin type's info hooks.
 * @param array $config
 *   The configuration options for the handler being created.
 *
 * @return
 *   A handler object instance of the specified plugin type.
 */
function layout_create_handler($plugin_type, $plugin_name, array $config = array()) {
  $handler_name = layout_get_handler_name($plugin_type, $plugin_name);
  return new $handler_name($plugin_name, $config);
}

/**
 * Helper function to create a Layout Context.
 *
 * @return LayoutContext
 */
function layout_create_relationship($relationship_plugin_name, $config = array()) {
  return layout_create_handler('layout_relationship', $relationship_plugin_name, $config);
}

/**
 * Helper function to create a Layout Context.
 *
 * @return LayoutContext
 */
function layout_create_context($context_plugin_name, $config = array()) {
  return layout_create_handler('layout_context', $context_plugin_name, $config);
}

/**
 * Helper function to create a Layout Access.
 *
 * @return LayoutAccess
 */
function layout_create_access($access_plugin_name, $config = array()) {
  return layout_create_handler('layout_access', $access_plugin_name, $config);
}

/**
 * Helper function to create a Layout Renderer.
 *
 * @return LayoutRendererStandard|LayoutRendererEditor
 */
function layout_create_renderer($renderer_plugin_name, Layout $layout) {
  // Renderers do not have "broken" classes if they do not exist. As renderers
  // are not part of configuration, they should never go missing.
  $renderer_info = layout_get_renderer_info($renderer_plugin_name);
  return new $renderer_info['class']($layout, $renderer_info);
}

/**
 * Get a layout or menu item currently being edited from the tempstore.
 *
 * If a layout is not yet being edited, the layout will be loaded from
 * configuration.
 *
 * @param string $name
 *   The machine name of the Layout item to load.
 * @param string $type
 *   The type of item to load. Must be either "layout" or "menu_item".
 */
function layout_get_layout_tempstore($name, $type = 'layout') {
  $caches = &backdrop_static(__FUNCTION__, array());

  if (!isset($caches[$type][$name])) {
    // Try loading from tempstore first to get in-progress changes.
    $item = tempstore_get('layout.' . $type, $name);

    if (!$item) {
      if ($type == 'layout') {
        $item = layout_load($name);
      }
      elseif ($type == 'menu_item') {
        $item = layout_menu_item_load($name);
      }
    }

    $caches[$type][$name] = $item;
  }

  return $caches[$type][$name];
}

/**
 * Store changes to a layout or menu item in the temporary store.
 *
 * @param Layout|LayoutMenuItem $item
 *   The Layout item to save into tempstore.
 * @param string $type
 *   The type of item to save. Must be either "layout" or "menu_item".
 */
function layout_set_layout_tempstore($item, $type = 'layout') {
  if (empty($item->name)) {
    return;
  }

  $item->locked = array(
    'uid' => $GLOBALS['user']->uid,
    'updated' => REQUEST_TIME,
  );
  tempstore_set('layout.' . $type, $item->name, $item, 604800);
}

/**
 * Remove an item from the object cache.
 */
function layout_clear_layout_tempstore($name, $type = 'layout') {
  tempstore_clear('layout.' . $type, $name);
}

/**
 * Menu loader callback to load a Layout cache object.
 */
function layout_tempstore_load($layout_name) {
  return layout_get_layout_tempstore($layout_name, 'layout');
}

/**
 * Menu loader callback to load a Layout cache object.
 */
function layout_tempstore_menu_item_load($layout_name) {
  return layout_get_layout_tempstore($layout_name, 'menu_item');
}

/**
 * Menu loader to load an individual block from a layout.
 */
function layout_tempstore_block_load($layout_block_uuid, $layout_name) {
  $layout = layout_tempstore_load($layout_name);
  $block = FALSE;

  if (isset($layout->in_progress['block']) && $layout->in_progress['block']->uuid === $layout_block_uuid) {
    $block = $layout->in_progress['block'];
  }
  elseif (isset($layout->content[$layout_block_uuid])) {
    $block = $layout->content[$layout_block_uuid];
  }

  return $block;
}

/**
 * Given a path with placeholders (%), determine the required contexts.
 *
 * @param string $path
 *   The path for which required contexts should be retrieved.
 *
 * @return array
 *   An array of required contexts that match the given path.
 */
function layout_context_required_by_path($path) {
  $required_context_info = array();

  // Populate each required context on the available known handlers.
  $all_info = _layout_get_all_info('layout_context');
  foreach ($all_info as $context_info) {
    foreach ($context_info['menu paths'] as $context_path) {
      // Remove named placeholders to just match on % symbols.
      $cleaned_path = preg_replace('/%[a-z0-9_]+/', '%', $context_path);

      // If it is an exact path match, assign the context without a position.
      if (strpos($path, '%') === FALSE && $path === $cleaned_path) {
        $required_context_info[$context_info['name']] = array(
          'plugin' => $context_info['name'],
        );
      }
      // If the path matches based on % placeholders, add this context as a
      // required context info in the correct order.
      elseif (strpos($path, $cleaned_path) === 0) {
        // Determine the argument placement within the path.
        $parts = explode('/', $context_path);
        foreach ($parts as $part_index => $part) {
          if (!empty($context_info['path placeholder']) && $part === $context_info['path placeholder']) {
            $required_context_info[$part_index] = array(
              'plugin' => $context_info['name'],
              'position' => $part_index,
            );
          }
        }
      }
    }
  }

  // If any placeholders are not filled, populate with a placeholder context
  // that can be modified.
  $parts = explode('/', $path);
  foreach ($parts as $part_index => $part) {
    if ($part === '%' && !isset($required_context_info[$part_index])) {
      $required_context_info[$part_index] = array(
        'plugin' => 'string',
        'position' => $part_index,
      );
    }
  }

  // Put the required contexts in order based on the path.
  ksort($required_context_info);

  // Convert required context info into objects.
  $required_contexts[$path] = array();
  foreach ($required_context_info as $context_position => $context_info) {
    $context = layout_create_context($context_info['plugin']);
    $context->required = TRUE;
    $context->usageType = LayoutContext::USAGE_TYPE_MENU;
    // String placeholders are not locked, allowing a new value to be set.
    $context->locked = $context_info['plugin'] !== 'string';
    $context->position = $context_position;
    $context->plugin = $context_info['plugin'];
    $required_contexts[$path][$context_position] = $context;
  }

  return $required_contexts[$path];
}

/**
 * Returns the current user account context, which is always available.
 *
 * @return EntityLayoutContext
 *   The layout context for the current user account.
 *
 * @since 1.17.5 Function added.
 */
function layout_current_user_context() {
  $current_user_context = layout_create_context('user', array(
    'name' => 'current_user',
    'label' => t('Logged-in user account'),
    'locked' => TRUE,
    'usageType' => LayoutContext::USAGE_TYPE_SYSTEM,
  ));
  $current_user_context->setData($GLOBALS['user']);

  return $current_user_context;
}

/**
 * Determine if a block has the necessary contexts.
 *
 * @param Layout $layout
 *   The layout on which the specified block will be displayed.
 * @param string $block_module
 *   The module that provides the block to be checked.
 * @param string $block_delta
 *   The identifier for the block within hook_block_info().
 *
 * @return bool
 *   TRUE if the block has required contexts. FALSE otherwise.
 */
function layout_block_has_required_contexts(Layout $layout, $block_module, $block_delta) {
  $block_info = module_invoke($block_module, 'block_info');
  $required_contexts = array();

  if (isset($block_info[$block_delta]['required contexts'])) {
    $required_contexts = $block_info[$block_delta]['required contexts'];
  }

  $available_contexts = $layout->getContexts();

  foreach ($required_contexts as $key => $required_context_plugin_name) {
    foreach ($available_contexts as $context) {
      if ($context->isA($required_context_plugin_name)) {
        // Matching context available, remove from required list.
        unset($required_contexts[$key]);
      }
    }
  }

  // If there are no missing contexts, all required contexts are available.
  return empty($required_contexts);
}

/**
 * Helper function for setting contexts on a layout handler.
 *
 * @param array $contexts
 *   An array of contexts that will be set by reference if all required contexts
 *   are found.
 * @param LayoutContext[] $all_contexts
 *   The full array of contexts on an entire layout, from which the required
 *   contexts will be selected.
 * @param array $required_contexts
 *   The array of context keys and types that need to be selected from
 *   the $all_contexts array and populated into the $contexts array.
 * @param array $context_settings
 *   If a plugin has multiple contexts, a user may select which context should
 *   be used. This array will be keyed by the plugin's required context keys,
 *   with the values being the overall layout's context keys.
 *
 * @return bool
 *   TRUE if all contexts were set on the Layout. If a requested context is not
 *   available, FALSE will be returned and no contexts will be set at all.
 */
function layout_set_handler_contexts(array &$contexts, array $all_contexts, array $required_contexts, array $context_settings) {
  foreach ($required_contexts as $required_context_key => $context_type) {
    // Use the configured context if available.
    if (isset($context_settings[$required_context_key])) {
      $layout_context_key = $context_settings[$required_context_key];
      if (isset($all_contexts[$layout_context_key]) && ($all_contexts[$layout_context_key]->isA($context_type))) {
        $contexts[$required_context_key] = $all_contexts[$layout_context_key];
        continue;
      }
    }

    // Otherwise use the first context that matches the right type.
    foreach ($all_contexts as $layout_context) {
      if ($layout_context->isA($context_type)) {
        $contexts[$required_context_key] = $layout_context;
        continue 2;
      }
    }

    // If we reach here, no matching required context was found, empty all
    // contexts to prevent partial functionality and return FALSE.
    $contexts = array();
    return FALSE;
  }

  // All required contexts populated successfully.
  return TRUE;
}

/**
 * Implements hook_modules_uninstalled().
 *
 * Deletes all blocks provided by a module when that module is uninstalled.
 */
function layout_modules_uninstalled($modules) {
  $layouts = layout_load_all();
  foreach ($modules as $module) {
    foreach ($layouts as $layout) {
      $blocks_to_remove = array();

      foreach ($layout->content as $uuid => $block) {
        if ($block->module == $module) {
          $blocks_to_remove[] = $uuid;
        }
      }

      if ($blocks_to_remove) {
        foreach ($blocks_to_remove as $uuid_to_remove) {
          $layout->removeBlock($uuid_to_remove);
        }
        $layout->save();
      }
    }
  }
}

/**
 * Gets the title description for the current layout.
 *
 * @param Layout $layout
 *   Full layout object.
 *
 * @return $description
 *   Description of title source.
 */
function layout_get_title_description(Layout $layout) {
  $source = $layout->settings['title_display'];
  switch ($source) {
    case LAYOUT_TITLE_DEFAULT:
      $description = t('Default page title');
      break;
    case LAYOUT_TITLE_CUSTOM:
      $description = t('Custom page title: %title', array('%title' => $layout->settings['title']));
      break;
    case LAYOUT_TITLE_BLOCK:
      $all_blocks = layout_get_block_info();
      if (!empty($layout->settings['title_block'])) {
        $uuid = $layout->settings['title_block'];
        $title_block = $layout->content[$uuid];
        $description = t('Title copied from the %block block', array('%block' => $all_blocks[$title_block->module][$title_block->delta]['info']));
      }
      break;
    case LAYOUT_TITLE_NONE:
      $description = t('No title');
      break;
  }

  return $description;
}

/**
 * Store changes to a flexible layout template in the temporary store.
 *
 * @param LayoutFlexibleTemplate $flexible_template
 *   The loaded flexible template object.
 * @param string $flexible_template_type
 *   The type of flexible template to save. Defaults to 'flexible'.
 */
function layout_flexible_tempstore_set(LayoutFlexibleTemplate $flexible_template, $flexible_template_type = 'flexible') {
  _layout_standardize_template_type($flexible_template_type);
  tempstore_set('layout.' . $flexible_template_type, $flexible_template->name, $flexible_template, 604800);
}

/**
 * Get a flexible template currently being edited from the tempstore.
 *
 * If a template is not yet being edited, the template will be loaded from
 * configuration.
 *
 * @param string $flexible_template_name
 *   The machine name of the flexible template to load.
 * @param string $flexible_template_type
 *   The type of flexible template to load. Defaults to 'flexible'.
 *
 * @return LayoutFlexibleTemplate
 *   The flexible template object.
 */
function layout_flexible_tempstore_load($flexible_template_name = NULL, $flexible_template_type = 'flexible') {
  _layout_standardize_template_type($flexible_template_type);
  if (!$flexible_template_name) {
    return new LayoutFlexibleTemplate();
  }

  $caches = &backdrop_static(__FUNCTION__ . ':' . $flexible_template_type, array());
  if (!isset($caches[$flexible_template_type . ':' . $flexible_template_name])) {
    if (!$item = tempstore_get('layout.' . $flexible_template_type, $flexible_template_name)) {
      $item = layout_flexible_template_load($flexible_template_name, $flexible_template_type);
    }
    $caches[$flexible_template_type . ':' . $flexible_template_name] = $item;
  }

  return $caches[$flexible_template_type . ':' . $flexible_template_name];
}

/**
 * Load an individual flexible template.
 *
 * @param string $flexible_template_name
 *   The machine name of the template to load.
 * @param string $flexible_type
 *   The type of flexible template to load. Defaults to 'flexible'.
 *
 * @return LayoutFlexibleTemplate|false
 */
function layout_flexible_template_load($flexible_template_name = NULL, $flexible_type = 'flexible') {
  _layout_standardize_template_type($flexible_type);
  $all_templates = layout_flexible_template_load_all($flexible_type);
  if (isset($all_templates[$flexible_template_name])) {
    return $all_templates[$flexible_template_name];
  }
  else {
    return FALSE;
  }
}

/**
 * Load all flexible templates by type. Defaults to 'flexible'.
 *
 * @param string $flexible_type
 *   The type of flexible template to load. Defaults to 'flexible'.
 *
 * @return LayoutFlexibleTemplate[]
 */
function layout_flexible_template_load_all($flexible_type = 'flexible') {
  _layout_standardize_template_type($flexible_type);
  $templates = &backdrop_static(__FUNCTION__ . ':' . $flexible_type, array());

  if (empty($templates)) {
    $cache = cache()->get('layout:' . $flexible_type . ':config');
    if ($cache && $cache->data) {
      $configs = $cache->data;
    }
    else {
      $configs = array();
      $config_names = config_get_names_with_prefix('layout.' . $flexible_type . '.');
      foreach ($config_names as $config_file) {
        $config = config($config_file);
        $data = $config->get();
        $configs[$data['name']] = $data;
      }

      cache()->set('layout:' . $flexible_type . ':config', $configs);
    }

    foreach ($configs as $template_name => $config) {
      $config['layout_template_type'] = $flexible_type;
      $templates[$template_name] = new LayoutFlexibleTemplate($config);
    }
  }

  return $templates;
}

/**
 * Returns whether a flexible layout template machine name already exists. This
 * function will also check if a layout template with the same machine name
 * exists, to prevent clashes on the core "Layout templates" listing page.
 *
 * @see layout_flexible_template_settings_edit_form()
 * @see form_validate_machine_name()
 */
function layout_flexible_template_machine_name_exists($value) {
  $exists = (bool) layout_flexible_template_load($value) || !empty(layout_get_layout_template_info($value));
  return $exists;
}

/**
 * Implements hook_layout_template_info().
 */
function layout_layout_template_info($flexible_template_type = 'flexible') {
  _layout_standardize_template_type($flexible_template_type);
  $layouts = array();
  $styles = layout_flexible_row_styles();

  $flexible_templates = layout_flexible_template_load_all($flexible_template_type);
  foreach ($flexible_templates as $flexible_template) {
    $layouts[$flexible_template->name] = array(
      'title' => $flexible_template->title,
      'description' => $flexible_template->description,
      'regions' => array(),
      'default region' => '',
      'template' => 'layout--flexible',
      'flexible' => TRUE,
      'type' => 'layout',
      'path' => 'templates',
      'preview' => $flexible_template->preview ?? 'flexible_template.png',
      'is_full_page' => $flexible_template->is_full_page ?? TRUE,
      'libraries' => array('bootstrap4-gs'),
    );

    foreach ($flexible_template->rows as $row_name => $region) {
      $region_style = $styles[$region['contains']];
      for ($i = 0; $i < $region_style['region_count']; $i++) {
        if (!empty($region['region_names']['region_' . $i]['label'])) {
          $region_name = $region['region_names']['region_' . $i]['label'];
        }
        else {
          $region_name = $row_name . ' ' . $i;
        }
        $layouts[$flexible_template->name]['regions'][$row_name . '--' . $i] = $region_name;
      }
    }
  }

  return $layouts;
}

/**
 * Implements hook_layout_presave().
 */
function layout_layout_presave($layout) {
  if (!empty($layout->additional_paths)) {
    $layout->settings['additional_paths'] = $layout->additional_paths;
  }

  if (!empty($layout->removed_blocks)) {
    foreach ($layout->removed_blocks as $uuid => $block) {
      // @todo: Follow-up for other block types with files/images.
      if (is_a($block, 'BlockHero')) {
        if (!empty($block->settings['image'])) {
          $image = file_load($block->settings['image']);
          if ($image) {
            file_usage_delete($image, 'layout', 'block', $image->fid);
          }
        }
      }
    }
  }
}

/**
 * Reset all caches provided by Layout module.
 */
function layout_flexible_reset_caches($flexible_template_type = 'flexible') {
  _layout_standardize_template_type($flexible_template_type);
  cache()->delete('layout:' . $flexible_template_type . ':config');

  backdrop_static_reset('layout_flexible_template_load_all:' . $flexible_template_type);
  backdrop_static_reset('layout_flexible_tempstore_load:' . $flexible_template_type);
}

/**
 * Provides the default row styles.
 */
function layout_flexible_row_styles() {
  $styles = array(
    'region_12' => array(
      'split' => '100:0',
      'bootstrap' => '12:0',
      'region_count' => 1,
      'name' => t('One full-width region'),
    ),
    'region_10_2' => array(
      'split' => '83:17',
      'bootstrap' => '10:2',
      'region_count' => 2,
      'name' => t('Two regions') . (' 83% : 17% '),
    ),
    'region_9_3' => array(
      'split' => '75:25',
      'bootstrap' => '9:3',
      'region_count' => 2,
      'name' => t('Two regions') . (' 75% : 25% '),
    ),
    'region_8_4' => array(
      'split' => '67:33',
      'bootstrap' => '8:4',
      'region_count' => 2,
      'name' => t('Two regions') . (' 67% : 33% '),
    ),
    'region_6_6' => array(
      'split' => '50:50',
      'bootstrap' => '6:6',
      'region_count' => 2,
      'name' => t('Two regions') . (' 50% : 50% '),
    ),
    'region_4_8' => array(
      'split' => '33:67',
      'bootstrap' => '4:8',
      'region_count' => 2,
      'name' => t('Two regions') . (' 33% : 67% '),
    ),
    'region_3_9' => array(
      'split' => '25:75',
      'bootstrap' => '3:9',
      'region_count' => 2,
      'name' => t('Two regions') . (' 25% : 75% '),
    ),
    'region_2_10' => array(
      'split' => '17:83',
      'bootstrap' => '2:10',
      'region_count' => 2,
      'name' => t('Two regions') . (' 17% : 83% '),
    ),
    'region_4_4_4' => array(
      'split' => '33:33:33',
      'bootstrap' => '4:4:4',
      'region_count' => 3,
      'name' => t('Three regions') . (' 33% : 33% : 33% '),
    ),
    'region_2_8_2' => array(
      'split' => '17:67:17',
      'bootstrap' => '2:8:2',
      'region_count' => 3,
      'name' => t('Three regions') . (' 17% : 67% : 17% '),
    ),
    'region_2_2_8' => array(
      'split' => '17:17:67',
      'bootstrap' => '2:2:8',
      'region_count' => 3,
      'name' => t('Three regions') . (' 17% : 17% : 67% '),
    ),
    'region_8_2_2' => array(
      'split' => '67:17:17',
      'bootstrap' => '8:2:2',
      'region_count' => 3,
      'name' => t('Three regions') . (' 67% : 17% : 17% '),
    ),
    'region_3_6_3' => array(
      'split' => '25:50:25',
      'bootstrap' => '3:6:3',
      'region_count' => 3,
      'name' => t('Three regions') . (' 25% : 50% : 25% '),
    ),
    'region_3_3_6' => array(
      'split' => '25:25:50',
      'bootstrap' => '3:3:6',
      'region_count' => 3,
      'name' => t('Three regions') . (' 25% : 25% : 50% '),
    ),
    'region_6_3_3' => array(
      'split' => '50:25:25',
      'bootstrap' => '6:3:3',
      'region_count' => 3,
      'name' => t('Three regions') . (' 50% : 25% : 25% '),
    ),
    'region_4_2_6' => array(
      'split' => '33:17:50',
      'bootstrap' => '4:2:6',
      'region_count' => 3,
      'name' => t('Three regions') . (' 33% : 17% : 50% '),
    ),
    'region_4_6_2' => array(
      'split' => '33:50:17',
      'bootstrap' => '4:6:2',
      'region_count' => 3,
      'name' => t('Three regions') . (' 33% : 50% : 17% '),
    ),
    'region_2_6_4' => array(
      'split' => '17:50:33',
      'bootstrap' => '2:6:4',
      'region_count' => 3,
      'name' => t('Three regions') . (' 17% : 50% : 33% '),
    ),
    'region_2_4_6' => array(
      'split' => '17:33:50',
      'bootstrap' => '2:4:6',
      'region_count' => 3,
      'name' => t('Three regions') . (' 17% : 33% : 50% '),
    ),
    'region_6_2_4' => array(
      'split' => '50:17:33',
      'bootstrap' => '6:2:4',
      'region_count' => 3,
      'name' => t('Three regions') . (' 50% : 17% : 33% '),
    ),
    'region_6_4_2' => array(
      'split' => '50:33:17',
      'bootstrap' => '6:4:2',
      'region_count' => 3,
      'name' => t('Three regions') . (' 50% : 33% : 17% '),
    ),
    'region_3_3_3_3' => array(
      'split' => '25:25:25:25',
      'bootstrap' => '3:3:3:3',
      'region_count' => 4,
      'name' => t('Four regions') . (' 25% : 25% : 25% : 25% '),
    ),
    'region_3_3_4_2' => array(
      'split' => '25:25:33:17',
      'bootstrap' => '3:3:4:2',
      'region_count' => 4,
      'name' => t('Four regions') . (' 25% : 25% : 33% : 17% '),
    ),
    'region_3_3_2_4' => array(
      'split' => '25:25:17:33',
      'bootstrap' => '3:3:2:4',
      'region_count' => 4,
      'name' => t('Four regions') . (' 25% : 25% : 17% : 33% '),
    ),
    'region_4_3_3_2' => array(
      'split' => '33:25:25:17',
      'bootstrap' => '4:3:3:2',
      'region_count' => 4,
      'name' => t('Four regions') . (' 33% : 25% : 25% : 17% '),
    ),
    'region_2_3_3_4' => array(
      'split' => '17:25:25:33',
      'bootstrap' => '2:3:3:4',
      'region_count' => 4,
      'name' => t('Four regions') . (' 17% : 25% : 25% : 33% '),
    ),
    'region_2_4_3_3' => array(
      'split' => '17:33:25:25',
      'bootstrap' => '2:4:3:3',
      'region_count' => 4,
      'name' => t('Four regions') . (' 17% : 33% : 25% : 25% '),
    ),
    'region_4_2_3_3' => array(
      'split' => '33:17:25:25',
      'bootstrap' => '4:2:3:3',
      'region_count' => 4,
      'name' => t('Four regions') . (' 33% : 17% : 25% : 25% '),
    ),
    'region_2_4_4_2' => array(
      'split' => '17:33:33:17',
      'bootstrap' => '2:4:4:2',
      'region_count' => 4,
      'name' => t('Four regions') . (' 17% : 33% : 33% : 17% '),
    ),
    'region_2_4_2_4' => array(
      'split' => '17:33:17:33',
      'bootstrap' => '2:4:2:4',
      'region_count' => 4,
      'name' => t('Four regions') . (' 17% : 33% : 17% : 33% '),
    ),
    'region_4_2_2_4' => array(
      'split' => '33:17:17:33',
      'bootstrap' => '4:2:2:4',
      'region_count' => 4,
      'name' => t('Four regions') . (' 33% : 17% : 17% : 33% '),
    ),
    'region_4_2_4_2' => array(
      'split' => '33:17:33:17',
      'bootstrap' => '4:2:4:2',
      'region_count' => 4,
      'name' => t('Four regions') . (' 33% : 17% : 33% : 17% '),
    ),
  );

  return $styles;
}

/**
 * Utility function to clean CSS for Layout UI.
 *
 * @param string $classes
 *   CSS classes, as entered into the Layout user interface.
 *
 * @return string
 *   String of sanitized classes separated by spaces.
 */
function _layout_clean_custom_css($classes = array()) {
  if (!empty($classes)) {
    $new_classes = explode(' ', $classes);
    foreach ($new_classes as $class) {
      $clean_classes[] = backdrop_clean_css_identifier($class, array());
    }

    $clean_classes = array_filter($clean_classes);
    return implode(' ', $clean_classes);
  }

  return '';
}

/**
 * Implements hook_field_delete_instance().
 */
function layout_field_delete_instance($instance) {
  cache('layout_path')->flush();
}

/**
 * Helper to standardize layout template type machine names and ensure we
 * don't have any namespace issues. If the type is in the reserved list, we can
 * use them as is, otherwise we'll ensure it starts with 'custom_' before
 * sending it back.
 *
 * @param string $layout_template_type
 *   The custom template type machine name to process, passed by reference.
 */
function _layout_standardize_template_type(string &$layout_template_type = 'flexible') {
  $reserved_types = array(
    'layout',
    'flexible',
  );
  if (!in_array($layout_template_type, $reserved_types) && strpos($layout_template_type, 'custom_') !== 0) {
    $layout_template_type = 'custom_' . $layout_template_type;
  }
}

/**
 * Ensure path is properly formed.
 *
 * @param array $form
 *   An associative array containing the structure of the form.
 * @param string $field_name
 *   The machine name of the field.
 * @param string $path
 *   The menu routing path, with all placeholders represented by "%" symbols.
 *
 * @return bool
 *   TRUE if error found, else FALSE
 */
function _layout_set_message_on_path_error(array &$form, $field_name, $path) {
  $parts = explode('/', $path);
  foreach ($parts as $part) {
    $wildcard_position = strpos($part, '%');
    if ($wildcard_position !== FALSE && ($wildcard_position > 0 || strlen($part) > 1)) {
      form_error($form[$field_name], t('Placeholders must be the only character in their part of the path i.e. "@part" should be "%".', array('@part' => $part)));
      return TRUE;
    }
  }
  return FALSE;
}
Functions

Name	Description
layout_autoload_info	Implements hook_autoload_info().
layout_block_has_required_contexts	Determine if a block has the necessary contexts.
layout_block_info	Implements hook_block_info().
layout_clear_layout_tempstore	Remove an item from the object cache.
layout_config_info	Implements hook_config_info().
layout_contextual_links_view_alter	Implements hook_contextual_links_view_alter()
layout_context_required_by_path	Given a path with placeholders (%), determine the required contexts.
layout_create_access	Helper function to create a Layout Access.
layout_create_context	Helper function to create a Layout Context.
layout_create_handler	Helper function to instantiate handlers when loading from config.
layout_create_relationship	Helper function to create a Layout Context.
layout_create_renderer	Helper function to create a Layout Renderer.
layout_current_user_context	Returns the current user account context, which is always available.
layout_entity_menu_title	Title callback: Returns a label for the action link to create bundle layouts.
layout_field_delete_instance	Implements hook_field_delete_instance().
layout_flexible_reset_caches	Reset all caches provided by Layout module.
layout_flexible_row_styles	Provides the default row styles.
layout_flexible_template_load	Load an individual flexible template.
layout_flexible_template_load_all	Load all flexible templates by type. Defaults to 'flexible'.
layout_flexible_template_machine_name_exists	Returns whether a flexible layout template machine name already exists. This function will also check if a layout template with the same machine name exists, to prevent clashes on the core "Layout templates" listing page.
layout_flexible_tempstore_load	Get a flexible template currently being edited from the tempstore.
layout_flexible_tempstore_set	Store changes to a flexible layout template in the temporary store.
layout_flush_caches	Implements hook_flush_caches().
layout_get_access_info	Load all layout access information from modules.
layout_get_all_configs	Read all configuration files from disk of a particular layout type.
layout_get_block_info	Get information about all blocks or just a single one.
layout_get_context_info	Load all layout context information from modules.
layout_get_handler_name	Helper function to get a handler class name based on the plugin name.
layout_get_layout_by_path	Get the layout which is active based on a path or router item.
layout_get_layout_info Deprecated	Load the layout template information for a single layout template name.
layout_get_layout_template_info	Load the information of either a single layout template or all available layout templates.
layout_get_layout_tempstore	Get a layout or menu item currently being edited from the tempstore.
layout_get_path_layout_names	Get a list of layouts that share a particular path.
layout_get_relationship_info	Load all layout relationship information from modules.
layout_get_renderer_info	Load all layout renderer information from modules.
layout_get_style_info	Load all layout style information from modules.
layout_get_title_description	Gets the title description for the current layout.
layout_layout_api	Implements hook_layout_api().
layout_layout_presave	Implements hook_layout_presave().
layout_layout_template_info	Implements hook_layout_template_info().
layout_library_info	Implements hook_library_info().
layout_load	Load an individual layout.
layout_load_all	Return an array of all layouts as fully loaded Layout objects.
layout_load_multiple	Load multiple layouts based on a particular criteria.
layout_load_multiple_by_path	Load all layouts at a given path.
layout_load_multiple_by_router_item	Load all layouts for a given router item and allow other modules to alter them and/or set their contexts.
layout_menu	Implements hook_menu().
layout_menu_item_load	Load an individual Layout menu item.
layout_menu_item_load_all	Return an array of all menu items as fully loaded LayoutMenuItem objects.
layout_menu_item_load_multiple	Load menu items by name.
layout_menu_item_load_multiple_by_path	Load an individual Layout menu item based on its path.
layout_modules_uninstalled	Implements hook_modules_uninstalled().
layout_page_access	Menu access callback; Check access for any Layout-provided page.
layout_page_menu_item	Create a menu item for Layout-provided pages.
layout_page_title	Menu title callback; Return the title for editing a layout.
layout_path_load	Menu loader callback; Convert %layout_path placeholders to loaded objects.
layout_permission	Implements hook_permission().
layout_provides_path	Check if a path is provided by Layout module, as in a custom layout path.
layout_relationships_get_relevant_info	Fetch all relevant relationships.
layout_reset_caches	Reset all caches provided by Layout module.
layout_route_handler	Route handler callback; Execute the current route item or wrap in a layout.
layout_set_handler_contexts	Helper function for setting contexts on a layout handler.
layout_set_layout_tempstore	Store changes to a layout or menu item in the temporary store.
layout_suppress	Suppress the layout.
layout_tempstore_block_load	Menu loader to load an individual block from a layout.
layout_tempstore_load	Menu loader callback to load a Layout cache object.
layout_tempstore_menu_item_load	Menu loader callback to load a Layout cache object.
layout_theme	Implements hook_theme()
_layout_clean_custom_css	Utility function to clean CSS for Layout UI.
_layout_get_all_info	Load layout-related information from modules.
_layout_include_files	Load all include files for modules that implement hook_layout_api().
_layout_set_message_on_path_error	Ensure path is properly formed.
_layout_standardize_template_type	Helper to standardize layout template type machine names and ensure we don't have any namespace issues. If the type is in the reserved list, we can use them as is, otherwise we'll ensure it starts with 'custom_' before sending it back.
Constants

Name	Description
BLOCK_DISABLED	Denotes that the block is disabled.
BLOCK_ENABLED	Denotes that the block is enabled.
LAYOUT_STORAGE_DEFAULT	Layout constant for module-defined layouts.
LAYOUT_STORAGE_NORMAL	Layouts constant for user-defined layouts.
LAYOUT_STORAGE_OVERRIDE	Layout constant for layouts that override module-defined presets.
LAYOUT_TITLE_BLOCK	Layout constant indicating the title of the layout comes from a block.
LAYOUT_TITLE_CUSTOM	Layout constant indicating the title of the layout is manually specified.
LAYOUT_TITLE_DEFAULT	Layout constant indicating the title of the layout is the default.
LAYOUT_TITLE_NONE	Layout constant indicating the title of the layout is not shown.
File

Functions

Constants

Directory
