You are here

Home » API reference » Zircon Profile 8 » BlockPageVariant.php

class BlockPageVariant in Zircon Profile 8

Same name and namespace in other branches
  1. 8.0 core/modules/block/src/Plugin/DisplayVariant/BlockPageVariant.php \Drupal\block\Plugin\DisplayVariant\BlockPageVariant

Provides a page display variant that decorates the main content with blocks.

To ensure essential information is displayed, each essential part of a page has a corresponding block plugin interface, so that BlockPageVariant can automatically provide a fallback in case no block for each of these interfaces is placed.

Plugin annotation


@PageDisplayVariant(
  id = "block_page",
  admin_label = @Translation("Page with blocks")
)

Hierarchy

Expanded class hierarchy of BlockPageVariant

See also

\Drupal\Core\Block\MainContentBlockPluginInterface

\Drupal\Core\Block\MessagesBlockPluginInterface

File

core/modules/block/src/Plugin/DisplayVariant/BlockPageVariant.php, line 37
Contains \Drupal\block\Plugin\DisplayVariant\BlockPageVariant.

Namespace

Drupal\block\Plugin\DisplayVariant
View source 
class BlockPageVariant extends VariantBase implements PageVariantInterface, ContainerFactoryPluginInterface {

  /**
   * The block repository.
   *
   * @var \Drupal\block\BlockRepositoryInterface
   */
  protected $blockRepository;

  /**
   * The block view builder.
   *
   * @var \Drupal\Core\Entity\EntityViewBuilderInterface
   */
  protected $blockViewBuilder;

  /**
   * The Block entity type list cache tags.
   *
   * @var string[]
   */
  protected $blockListCacheTags;

  /**
   * The render array representing the main page content.
   *
   * @var array
   */
  protected $mainContent = [];

  /**
   * The page title: a string (plain title) or a render array (formatted title).
   *
   * @var string|array
   */
  protected $title = '';

  /**
   * Constructs a new BlockPageVariant.
   *
   * @param array $configuration
   *   A configuration array containing information about the plugin instance.
   * @param string $plugin_id
   *   The plugin ID for the plugin instance.
   * @param mixed $plugin_definition
   *   The plugin implementation definition.
   * @param \Drupal\block\BlockRepositoryInterface $block_repository
   *   The block repository.
   * @param \Drupal\Core\Entity\EntityViewBuilderInterface $block_view_builder
   *   The block view builder.
   * @param string[] $block_list_cache_tags
   *   The Block entity type list cache tags.
   */
  public function __construct(array $configuration, $plugin_id, $plugin_definition, BlockRepositoryInterface $block_repository, EntityViewBuilderInterface $block_view_builder, array $block_list_cache_tags) {
    parent::__construct($configuration, $plugin_id, $plugin_definition);
    $this->blockRepository = $block_repository;
    $this->blockViewBuilder = $block_view_builder;
    $this->blockListCacheTags = $block_list_cache_tags;
  }

  /**
   * {@inheritdoc}
   */
  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
    return new static($configuration, $plugin_id, $plugin_definition, $container
      ->get('block.repository'), $container
      ->get('entity.manager')
      ->getViewBuilder('block'), $container
      ->get('entity.manager')
      ->getDefinition('block')
      ->getListCacheTags());
  }

  /**
   * {@inheritdoc}
   */
  public function setMainContent(array $main_content) {
    $this->mainContent = $main_content;
    return $this;
  }

  /**
   * {@inheritdoc}
   */
  public function setTitle($title) {
    $this->title = $title;
    return $this;
  }

  /**
   * {@inheritdoc}
   */
  public function build() {

    // Track whether blocks showing the main content and messages are displayed.
    $main_content_block_displayed = FALSE;
    $messages_block_displayed = FALSE;
    $build = [
      '#cache' => [
        'tags' => $this->blockListCacheTags,
      ],
    ];

    // Load all region content assigned via blocks.
    $cacheable_metadata_list = [];
    foreach ($this->blockRepository
      ->getVisibleBlocksPerRegion($cacheable_metadata_list) as $region => $blocks) {

      /** @var $blocks \Drupal\block\BlockInterface[] */
      foreach ($blocks as $key => $block) {
        $block_plugin = $block
          ->getPlugin();
        if ($block_plugin instanceof MainContentBlockPluginInterface) {
          $block_plugin
            ->setMainContent($this->mainContent);
          $main_content_block_displayed = TRUE;
        }
        elseif ($block_plugin instanceof TitleBlockPluginInterface) {
          $block_plugin
            ->setTitle($this->title);
        }
        elseif ($block_plugin instanceof MessagesBlockPluginInterface) {
          $messages_block_displayed = TRUE;
        }
        $build[$region][$key] = $this->blockViewBuilder
          ->view($block);

        // The main content block cannot be cached: it is a placeholder for the
        // render array returned by the controller. It should be rendered as-is,
        // with other placed blocks "decorating" it. Analogous reasoning for the
        // title block.
        if ($block_plugin instanceof MainContentBlockPluginInterface || $block_plugin instanceof TitleBlockPluginInterface) {
          unset($build[$region][$key]['#cache']['keys']);
        }
      }
      if (!empty($build[$region])) {

        // \Drupal\block\BlockRepositoryInterface::getVisibleBlocksPerRegion()
        // returns the blocks in sorted order.
        $build[$region]['#sorted'] = TRUE;
      }
    }

    // If no block that shows the main content is displayed, still show the main
    // content. Otherwise the end user will see all displayed blocks, but not
    // the main content they came for.
    if (!$main_content_block_displayed) {
      $build['content']['system_main'] = $this->mainContent;
    }

    // If no block displays status messages, still render them.
    if (!$messages_block_displayed) {
      $build['content']['messages'] = [
        '#weight' => -1000,
        '#type' => 'status_messages',
      ];
    }

    // If any render arrays are manually placed, render arrays and blocks must
    // be sorted.
    if (!$main_content_block_displayed || !$messages_block_displayed) {
      unset($build['content']['#sorted']);
    }

    // The access results' cacheability is currently added to the top level of the
    // render array. This is done to prevent issues with empty regions being
    // displayed.
    // This would need to be changed to allow caching of block regions, as each
    // region must then have the relevant cacheable metadata.
    $merged_cacheable_metadata = CacheableMetadata::createFromRenderArray($build);
    foreach ($cacheable_metadata_list as $cacheable_metadata) {
      $merged_cacheable_metadata = $merged_cacheable_metadata
        ->merge($cacheable_metadata);
    }
    $merged_cacheable_metadata
      ->applyTo($build);
    return $build;
  }

}

Members

Namesort descending Modifiers Type Description Overrides
BlockPageVariant::$blockListCacheTags protected property The Block entity type list cache tags.
BlockPageVariant::$blockRepository protected property The block repository.
BlockPageVariant::$blockViewBuilder protected property The block view builder.
BlockPageVariant::$mainContent protected property The render array representing the main page content.
BlockPageVariant::$title protected property The page title: a string (plain title) or a render array (formatted title).
BlockPageVariant::build public function Builds and returns the renderable array for the display variant. Overrides VariantInterface::build
BlockPageVariant::create public static function Creates an instance of the plugin. Overrides ContainerFactoryPluginInterface::create
BlockPageVariant::setMainContent public function Sets the main content for the page being rendered. Overrides PageVariantInterface::setMainContent
BlockPageVariant::setTitle public function Sets the title for the page being rendered. Overrides PageVariantInterface::setTitle
BlockPageVariant::__construct public function Constructs a new BlockPageVariant. Overrides VariantBase::__construct
DependencySerializationTrait::$_serviceIds protected property An array of service IDs keyed by property name used for serialization.
DependencySerializationTrait::__sleep public function 1
DependencySerializationTrait::__wakeup public function 2
DependencyTrait::$dependencies protected property The object's dependencies. 1
DependencyTrait::addDependencies protected function Adds multiple dependencies.
DependencyTrait::addDependency protected function Adds a dependency.
PluginBase::$configuration protected property Configuration information passed into the plugin. 2
PluginBase::$pluginDefinition protected property The plugin implementation definition.
PluginBase::$pluginId protected property The plugin_id.
PluginBase::DERIVATIVE_SEPARATOR constant A string which is used to separate base plugin IDs from the derivative ID.
PluginBase::getBaseId public function Gets the base_plugin_id of the plugin instance. Overrides DerivativeInspectionInterface::getBaseId
PluginBase::getDerivativeId public function Gets the derivative_id of the plugin instance. Overrides DerivativeInspectionInterface::getDerivativeId
PluginBase::getPluginDefinition public function Gets the definition of the plugin implementation. Overrides PluginInspectionInterface::getPluginDefinition
PluginBase::getPluginId public function Gets the plugin_id of the plugin instance. Overrides PluginInspectionInterface::getPluginId
PluginDependencyTrait::calculatePluginDependencies protected function Calculates and adds dependencies of a specific plugin instance. 1
RefinableCacheableDependencyTrait::$cacheContexts protected property Cache contexts.
RefinableCacheableDependencyTrait::$cacheMaxAge protected property Cache max-age.
RefinableCacheableDependencyTrait::$cacheTags protected property Cache tags.
RefinableCacheableDependencyTrait::addCacheableDependency public function 1
RefinableCacheableDependencyTrait::addCacheContexts public function
RefinableCacheableDependencyTrait::addCacheTags public function
RefinableCacheableDependencyTrait::getCacheContexts public function 4
RefinableCacheableDependencyTrait::getCacheMaxAge public function 4
RefinableCacheableDependencyTrait::getCacheTags public function 4
RefinableCacheableDependencyTrait::mergeCacheMaxAge public function
StringTranslationTrait::$stringTranslation protected property The string translation service.
StringTranslationTrait::formatPlural protected function Formats a string containing a count of items.
StringTranslationTrait::getNumberOfPlurals protected function Returns the number of plurals supported by a given language.
StringTranslationTrait::getStringTranslation protected function Gets the string translation service.
StringTranslationTrait::setStringTranslation public function Sets the string translation service to use. 2
StringTranslationTrait::t protected function Translates a string to the current language or to a given language.
VariantBase::access public function Determines if this display variant is accessible. Overrides VariantInterface::access
VariantBase::adminLabel public function Returns the admin-facing display variant label. Overrides VariantInterface::adminLabel
VariantBase::buildConfigurationForm public function Form constructor. Overrides PluginFormInterface::buildConfigurationForm
VariantBase::calculateDependencies public function Calculates dependencies for the configured plugin. Overrides DependentPluginInterface::calculateDependencies
VariantBase::defaultConfiguration public function Gets default configuration for this plugin. Overrides ConfigurablePluginInterface::defaultConfiguration
VariantBase::getConfiguration public function Gets this plugin's configuration. Overrides ConfigurablePluginInterface::getConfiguration
VariantBase::getWeight public function Returns the weight of the display variant. Overrides VariantInterface::getWeight
VariantBase::id public function Returns the unique ID for the display variant. Overrides VariantInterface::id
VariantBase::label public function Returns the user-facing display variant label. Overrides VariantInterface::label
VariantBase::setConfiguration public function Sets the configuration for this plugin instance. Overrides ConfigurablePluginInterface::setConfiguration
VariantBase::setWeight public function Sets the weight of the display variant. Overrides VariantInterface::setWeight
VariantBase::submitConfigurationForm public function Form submission handler. Overrides PluginFormInterface::submitConfigurationForm
VariantBase::validateConfigurationForm public function Form validation handler. Overrides PluginFormInterface::validateConfigurationForm