class BlockPageVariant

Same name in other branches
  1. 9 core/modules/block/src/Plugin/DisplayVariant/BlockPageVariant.php \Drupal\block\Plugin\DisplayVariant\BlockPageVariant
  2. 10 core/modules/block/src/Plugin/DisplayVariant/BlockPageVariant.php \Drupal\block\Plugin\DisplayVariant\BlockPageVariant
  3. 11.x 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

1 file declares its use of BlockPageVariant
PlaceBlockPageVariant.php in core/modules/block_place/src/Plugin/DisplayVariant/PlaceBlockPageVariant.php

File

core/modules/block/src/Plugin/DisplayVariant/BlockPageVariant.php, line 32

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_type.manager')
            ->getViewBuilder('block'), $container->get('entity_type.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',
                '#include_fallback' => TRUE,
            ];
        }
        // 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

Title Sort descending Modifiers Object type Summary Overriden Title 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 1
BlockPageVariant::create public static function Creates an instance of the plugin. Overrides ContainerFactoryPluginInterface::create 1
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 1
CacheableDependencyTrait::$cacheContexts protected property Cache contexts.
CacheableDependencyTrait::$cacheMaxAge protected property Cache max-age.
CacheableDependencyTrait::$cacheTags protected property Cache tags.
CacheableDependencyTrait::getCacheContexts public function 4
CacheableDependencyTrait::getCacheMaxAge public function 4
CacheableDependencyTrait::getCacheTags public function 4
CacheableDependencyTrait::setCacheability protected function Sets cacheability; useful for value object constructors.
DependencyTrait::$dependencies protected property The object's dependencies.
DependencyTrait::addDependencies protected function Adds multiple dependencies.
DependencyTrait::addDependency protected function Adds a dependency.
PluginDependencyTrait::calculatePluginDependencies protected function Calculates and adds dependencies of a specific plugin instance. 1
PluginDependencyTrait::getPluginDependencies protected function Calculates and returns dependencies of a specific plugin instance.
PluginDependencyTrait::moduleHandler protected function Wraps the module handler. 1
PluginDependencyTrait::themeHandler protected function Wraps the theme handler. 1
PluginInspectionInterface::getPluginDefinition public function Gets the definition of the plugin implementation. 6
PluginInspectionInterface::getPluginId public function Gets the plugin_id of the plugin instance. 2
RefinableCacheableDependencyTrait::addCacheableDependency public function 1
RefinableCacheableDependencyTrait::addCacheContexts public function
RefinableCacheableDependencyTrait::addCacheTags public function
RefinableCacheableDependencyTrait::mergeCacheMaxAge public function
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 ConfigurableInterface::defaultConfiguration
VariantBase::getConfiguration public function Gets this plugin's configuration. Overrides ConfigurableInterface::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 ConfigurableInterface::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

Buggy or inaccurate documentation? Please file an issue. Need support? Need help programming? Connect with the Drupal community.