class LayoutBuilderEntityViewDisplay in Drupal 8

Same name and namespace in other branches

9 core/modules/layout_builder/src/Entity/LayoutBuilderEntityViewDisplay.php \Drupal\layout_builder\Entity\LayoutBuilderEntityViewDisplay

Provides an entity view display entity that has a layout.

Hierarchy

class \Drupal\Core\Entity\EntityBase implements EntityInterface uses RefinableCacheableDependencyTrait, DependencySerializationTrait
- class \Drupal\Core\Config\Entity\ConfigEntityBase implements ConfigEntityInterface uses SynchronizableEntityTrait, PluginDependencyTrait
  - class \Drupal\Core\Entity\EntityDisplayBase implements EntityDisplayInterface
    class \Drupal\Core\Entity\Entity\EntityViewDisplay implements EntityViewDisplayInterface
    class \Drupal\layout_builder\Entity\LayoutBuilderEntityViewDisplay implements LayoutEntityDisplayInterface uses LayoutEntityHelperTrait, SectionStorageTrait

Expanded class hierarchy of LayoutBuilderEntityViewDisplay

14 files declare their use of LayoutBuilderEntityViewDisplay

DefaultsSectionStorageTest.php in core/modules/layout_builder/tests/src/Kernel/DefaultsSectionStorageTest.php
InlineBlockTest.php in core/modules/layout_builder/tests/src/FunctionalJavascript/InlineBlockTest.php
LayoutBuilderAccessTest.php in core/modules/layout_builder/tests/src/Functional/LayoutBuilderAccessTest.php
LayoutBuilderContentModerationIntegrationTest.php in core/modules/content_moderation/tests/src/Functional/LayoutBuilderContentModerationIntegrationTest.php
LayoutBuilderEntityViewDisplayTest.php in core/modules/layout_builder/tests/src/Kernel/LayoutBuilderEntityViewDisplayTest.php

... See full list

File

core/modules/layout_builder/src/Entity/LayoutBuilderEntityViewDisplay.php, line 29

Namespace

Drupal\layout_builder\Entity

View source

class LayoutBuilderEntityViewDisplay extends BaseEntityViewDisplay implements LayoutEntityDisplayInterface {
  use SectionStorageTrait;
  use LayoutEntityHelperTrait;

  /**
   * The entity field manager.
   *
   * @var \Drupal\Core\Entity\EntityFieldManagerInterface
   */
  protected $entityFieldManager;

  /**
   * {@inheritdoc}
   */
  public function __construct(array $values, $entity_type) {

    // Set $entityFieldManager before calling the parent constructor because the
    // constructor will call init() which then calls setComponent() which needs
    // $entityFieldManager.
    $this->entityFieldManager = \Drupal::service('entity_field.manager');
    parent::__construct($values, $entity_type);
  }

  /**
   * {@inheritdoc}
   */
  public function isOverridable() {
    return $this
      ->isLayoutBuilderEnabled() && $this
      ->getThirdPartySetting('layout_builder', 'allow_custom', FALSE);
  }

  /**
   * {@inheritdoc}
   */
  public function setOverridable($overridable = TRUE) {
    $this
      ->setThirdPartySetting('layout_builder', 'allow_custom', $overridable);

    // Enable Layout Builder if it's not already enabled and overriding.
    if ($overridable && !$this
      ->isLayoutBuilderEnabled()) {
      $this
        ->enableLayoutBuilder();
    }
    return $this;
  }

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

    // Layout Builder must not be enabled for the '_custom' view mode that is
    // used for on-the-fly rendering of fields in isolation from the entity.
    if ($this
      ->isCustomMode()) {
      return FALSE;
    }
    return (bool) $this
      ->getThirdPartySetting('layout_builder', 'enabled');
  }

  /**
   * {@inheritdoc}
   */
  public function enableLayoutBuilder() {
    $this
      ->setThirdPartySetting('layout_builder', 'enabled', TRUE);
    return $this;
  }

  /**
   * {@inheritdoc}
   */
  public function disableLayoutBuilder() {
    $this
      ->setOverridable(FALSE);
    $this
      ->setThirdPartySetting('layout_builder', 'enabled', FALSE);
    return $this;
  }

  /**
   * {@inheritdoc}
   */
  public function getSections() {
    return $this
      ->getThirdPartySetting('layout_builder', 'sections', []);
  }

  /**
   * {@inheritdoc}
   */
  protected function setSections(array $sections) {

    // Third-party settings must be completely unset instead of stored as an
    // empty array.
    if (!$sections) {
      $this
        ->unsetThirdPartySetting('layout_builder', 'sections');
    }
    else {
      $this
        ->setThirdPartySetting('layout_builder', 'sections', array_values($sections));
    }
    return $this;
  }

  /**
   * {@inheritdoc}
   */
  public function preSave(EntityStorageInterface $storage) {
    parent::preSave($storage);
    $original_value = isset($this->original) ? $this->original
      ->isOverridable() : FALSE;
    $new_value = $this
      ->isOverridable();
    if ($original_value !== $new_value) {
      $entity_type_id = $this
        ->getTargetEntityTypeId();
      $bundle = $this
        ->getTargetBundle();
      if ($new_value) {
        $this
          ->addSectionField($entity_type_id, $bundle, OverridesSectionStorage::FIELD_NAME);
      }
      else {
        $this
          ->removeSectionField($entity_type_id, $bundle, OverridesSectionStorage::FIELD_NAME);
      }
    }
    $already_enabled = isset($this->original) ? $this->original
      ->isLayoutBuilderEnabled() : FALSE;
    $set_enabled = $this
      ->isLayoutBuilderEnabled();
    if ($already_enabled !== $set_enabled) {
      if ($set_enabled) {

        // Loop through all existing field-based components and add them as
        // section-based components.
        $components = $this
          ->getComponents();

        // Sort the components by weight.
        uasort($components, 'Drupal\\Component\\Utility\\SortArray::sortByWeightElement');
        foreach ($components as $name => $component) {
          $this
            ->setComponent($name, $component);
        }
      }
      else {

        // When being disabled, remove all existing section data.
        $this
          ->removeAllSections();
      }
    }
  }

  /**
   * Removes a layout section field if it is no longer needed.
   *
   * Because the field is shared across all view modes, the field will only be
   * removed if no other view modes are using it.
   *
   * @param string $entity_type_id
   *   The entity type ID.
   * @param string $bundle
   *   The bundle.
   * @param string $field_name
   *   The name for the layout section field.
   */
  protected function removeSectionField($entity_type_id, $bundle, $field_name) {
    $query = $this
      ->entityTypeManager()
      ->getStorage($this
      ->getEntityTypeId())
      ->getQuery()
      ->condition('targetEntityType', $this
      ->getTargetEntityTypeId())
      ->condition('bundle', $this
      ->getTargetBundle())
      ->condition('mode', $this
      ->getMode(), '<>')
      ->condition('third_party_settings.layout_builder.allow_custom', TRUE);
    $enabled = (bool) $query
      ->count()
      ->execute();
    if (!$enabled && ($field = FieldConfig::loadByName($entity_type_id, $bundle, $field_name))) {
      $field
        ->delete();
    }
  }

  /**
   * Adds a layout section field to a given bundle.
   *
   * @param string $entity_type_id
   *   The entity type ID.
   * @param string $bundle
   *   The bundle.
   * @param string $field_name
   *   The name for the layout section field.
   */
  protected function addSectionField($entity_type_id, $bundle, $field_name) {
    $field = FieldConfig::loadByName($entity_type_id, $bundle, $field_name);
    if (!$field) {
      $field_storage = FieldStorageConfig::loadByName($entity_type_id, $field_name);
      if (!$field_storage) {
        $field_storage = FieldStorageConfig::create([
          'entity_type' => $entity_type_id,
          'field_name' => $field_name,
          'type' => 'layout_section',
          'locked' => TRUE,
        ]);
        $field_storage
          ->setTranslatable(FALSE);
        $field_storage
          ->save();
      }
      $field = FieldConfig::create([
        'field_storage' => $field_storage,
        'bundle' => $bundle,
        'label' => t('Layout'),
      ]);
      $field
        ->setTranslatable(FALSE);
      $field
        ->save();
    }
  }

  /**
   * {@inheritdoc}
   */
  public function createCopy($mode) {

    // Disable Layout Builder and remove any sections copied from the original.
    return parent::createCopy($mode)
      ->setSections([])
      ->disableLayoutBuilder();
  }

  /**
   * {@inheritdoc}
   */
  protected function getDefaultRegion() {
    if ($this
      ->hasSection(0)) {
      return $this
        ->getSection(0)
        ->getDefaultRegion();
    }
    return parent::getDefaultRegion();
  }

  /**
   * Wraps the context repository service.
   *
   * @return \Drupal\Core\Plugin\Context\ContextRepositoryInterface
   *   The context repository service.
   */
  protected function contextRepository() {
    return \Drupal::service('context.repository');
  }

  /**
   * Indicates if this display is using the '_custom' view mode.
   *
   * @return bool
   *   TRUE if this display is using the '_custom' view mode, FALSE otherwise.
   */
  protected function isCustomMode() {
    return $this
      ->getOriginalMode() === static::CUSTOM_MODE;
  }

  /**
   * {@inheritdoc}
   */
  public function buildMultiple(array $entities) {
    $build_list = parent::buildMultiple($entities);

    // Layout Builder can not be enabled for the '_custom' view mode that is
    // used for on-the-fly rendering of fields in isolation from the entity.
    if ($this
      ->isCustomMode()) {
      return $build_list;
    }
    foreach ($entities as $id => $entity) {
      $build_list[$id]['_layout_builder'] = $this
        ->buildSections($entity);

      // If there are any sections, remove all fields with configurable display
      // from the existing build. These fields are replicated within sections as
      // field blocks by ::setComponent().
      if (!Element::isEmpty($build_list[$id]['_layout_builder'])) {
        foreach ($build_list[$id] as $name => $build_part) {
          $field_definition = $this
            ->getFieldDefinition($name);
          if ($field_definition && $field_definition
            ->isDisplayConfigurable($this->displayContext)) {
            unset($build_list[$id][$name]);
          }
        }
      }
    }
    return $build_list;
  }

  /**
   * Builds the render array for the sections of a given entity.
   *
   * @param \Drupal\Core\Entity\FieldableEntityInterface $entity
   *   The entity.
   *
   * @return array
   *   The render array representing the sections of the entity.
   */
  protected function buildSections(FieldableEntityInterface $entity) {
    $contexts = $this
      ->getContextsForEntity($entity);

    // @todo Remove in https://www.drupal.org/project/drupal/issues/3018782.
    $label = new TranslatableMarkup('@entity being viewed', [
      '@entity' => $entity
        ->getEntityType()
        ->getSingularLabel(),
    ]);
    $contexts['layout_builder.entity'] = EntityContext::fromEntity($entity, $label);
    $cacheability = new CacheableMetadata();
    $storage = $this
      ->sectionStorageManager()
      ->findByContext($contexts, $cacheability);
    $build = [];
    if ($storage) {
      foreach ($storage
        ->getSections() as $delta => $section) {
        $build[$delta] = $section
          ->toRenderArray($contexts);
      }
    }

    // The render array is built based on decisions made by @SectionStorage
    // plugins and therefore it needs to depend on the accumulated
    // cacheability of those decisions.
    $cacheability
      ->applyTo($build);
    return $build;
  }

  /**
   * Gets the available contexts for a given entity.
   *
   * @param \Drupal\Core\Entity\FieldableEntityInterface $entity
   *   The entity.
   *
   * @return \Drupal\Core\Plugin\Context\ContextInterface[]
   *   An array of context objects for a given entity.
   */
  protected function getContextsForEntity(FieldableEntityInterface $entity) {
    return [
      'view_mode' => new Context(ContextDefinition::create('string'), $this
        ->getMode()),
      'entity' => EntityContext::fromEntity($entity),
      'display' => EntityContext::fromEntity($this),
    ] + $this
      ->contextRepository()
      ->getAvailableContexts();
  }

  /**
   * Gets the runtime sections for a given entity.
   *
   * @param \Drupal\Core\Entity\FieldableEntityInterface $entity
   *   The entity.
   *
   * @return \Drupal\layout_builder\Section[]
   *   The sections.
   *
   * @deprecated in drupal:8.7.0 and is removed from drupal:9.0.0.
   *   \Drupal\layout_builder\SectionStorage\SectionStorageManagerInterface::findByContext()
   *   should be used instead. See https://www.drupal.org/node/3022574.
   */
  protected function getRuntimeSections(FieldableEntityInterface $entity) {
    @trigger_error('\\Drupal\\layout_builder\\Entity\\LayoutBuilderEntityViewDisplay::getRuntimeSections() is deprecated in Drupal 8.7.0 and will be removed before Drupal 9.0.0. \\Drupal\\layout_builder\\SectionStorage\\SectionStorageManagerInterface::findByContext() should be used instead. See https://www.drupal.org/node/3022574.', E_USER_DEPRECATED);

    // For backwards compatibility, mimic the functionality of ::buildSections()
    // by constructing a cacheable metadata object and retrieving the
    // entity-based contexts.
    $cacheability = new CacheableMetadata();
    $contexts = $this
      ->getContextsForEntity($entity);
    $storage = $this
      ->sectionStorageManager()
      ->findByContext($contexts, $cacheability);
    return $storage ? $storage
      ->getSections() : [];
  }

  /**
   * {@inheritdoc}
   *
   * @todo Move this upstream in https://www.drupal.org/node/2939931.
   */
  public function label() {
    $bundle_info = \Drupal::service('entity_type.bundle.info')
      ->getBundleInfo($this
      ->getTargetEntityTypeId());
    $bundle_label = $bundle_info[$this
      ->getTargetBundle()]['label'];
    $target_entity_type = $this
      ->entityTypeManager()
      ->getDefinition($this
      ->getTargetEntityTypeId());
    return new TranslatableMarkup('@bundle @label', [
      '@bundle' => $bundle_label,
      '@label' => $target_entity_type
        ->getPluralLabel(),
    ]);
  }

  /**
   * {@inheritdoc}
   */
  public function calculateDependencies() {
    parent::calculateDependencies();
    foreach ($this
      ->getSections() as $delta => $section) {
      $this
        ->calculatePluginDependencies($section
        ->getLayout());
      foreach ($section
        ->getComponents() as $uuid => $component) {
        $this
          ->calculatePluginDependencies($component
          ->getPlugin());
      }
    }
    return $this;
  }

  /**
   * {@inheritdoc}
   */
  public function onDependencyRemoval(array $dependencies) {
    $changed = parent::onDependencyRemoval($dependencies);

    // Loop through all sections and determine if the removed dependencies are
    // used by their layout plugins.
    foreach ($this
      ->getSections() as $delta => $section) {
      $layout_dependencies = $this
        ->getPluginDependencies($section
        ->getLayout());
      $layout_removed_dependencies = $this
        ->getPluginRemovedDependencies($layout_dependencies, $dependencies);
      if ($layout_removed_dependencies) {

        // @todo Allow the plugins to react to their dependency removal in
        //   https://www.drupal.org/project/drupal/issues/2579743.
        $this
          ->removeSection($delta);
        $changed = TRUE;
      }
      else {
        foreach ($section
          ->getComponents() as $uuid => $component) {
          $plugin_dependencies = $this
            ->getPluginDependencies($component
            ->getPlugin());
          $component_removed_dependencies = $this
            ->getPluginRemovedDependencies($plugin_dependencies, $dependencies);
          if ($component_removed_dependencies) {

            // @todo Allow the plugins to react to their dependency removal in
            //   https://www.drupal.org/project/drupal/issues/2579743.
            $section
              ->removeComponent($uuid);
            $changed = TRUE;
          }
        }
      }
    }
    return $changed;
  }

  /**
   * {@inheritdoc}
   */
  public function setComponent($name, array $options = []) {
    parent::setComponent($name, $options);

    // Only continue if Layout Builder is enabled.
    if (!$this
      ->isLayoutBuilderEnabled()) {
      return $this;
    }

    // Retrieve the updated options after the parent:: call.
    $options = $this->content[$name];

    // Provide backwards compatibility by converting to a section component.
    $field_definition = $this
      ->getFieldDefinition($name);
    $extra_fields = $this->entityFieldManager
      ->getExtraFields($this
      ->getTargetEntityTypeId(), $this
      ->getTargetBundle());
    $is_view_configurable_non_extra_field = $field_definition && $field_definition
      ->isDisplayConfigurable('view') && isset($options['type']);
    if ($is_view_configurable_non_extra_field || isset($extra_fields['display'][$name])) {
      $configuration = [
        'label_display' => '0',
        'context_mapping' => [
          'entity' => 'layout_builder.entity',
        ],
      ];
      if ($is_view_configurable_non_extra_field) {
        $configuration['id'] = 'field_block:' . $this
          ->getTargetEntityTypeId() . ':' . $this
          ->getTargetBundle() . ':' . $name;
        $keys = array_flip([
          'type',
          'label',
          'settings',
          'third_party_settings',
        ]);
        $configuration['formatter'] = array_intersect_key($options, $keys);
      }
      else {
        $configuration['id'] = 'extra_field_block:' . $this
          ->getTargetEntityTypeId() . ':' . $this
          ->getTargetBundle() . ':' . $name;
      }
      $section = $this
        ->getDefaultSection();
      $region = isset($options['region']) ? $options['region'] : $section
        ->getDefaultRegion();
      $new_component = new SectionComponent(\Drupal::service('uuid')
        ->generate(), $region, $configuration);
      $section
        ->appendComponent($new_component);
    }
    return $this;
  }

  /**
   * Gets a default section.
   *
   * @return \Drupal\layout_builder\Section
   *   The default section.
   */
  protected function getDefaultSection() {

    // If no section exists, append a new one.
    if (!$this
      ->hasSection(0)) {
      $this
        ->appendSection(new Section('layout_onecol'));
    }

    // Return the first section.
    return $this
      ->getSection(0);
  }

  /**
   * Gets the section storage manager.
   *
   * @return \Drupal\layout_builder\SectionStorage\SectionStorageManagerInterface
   *   The section storage manager.
   */
  private function sectionStorageManager() {
    return \Drupal::service('plugin.manager.layout_builder.section_storage');
  }

  /**
   * {@inheritdoc}
   */
  public function getComponent($name) {
    if ($this
      ->isLayoutBuilderEnabled() && ($section_component = $this
      ->getQuickEditSectionComponent() ?: $this
      ->getSectionComponentForFieldName($name))) {
      $plugin = $section_component
        ->getPlugin();
      if ($plugin instanceof ConfigurableInterface) {
        $configuration = $plugin
          ->getConfiguration();
        if (isset($configuration['formatter'])) {
          return $configuration['formatter'];
        }
      }
    }
    return parent::getComponent($name);
  }

  /**
   * Returns the Quick Edit formatter settings.
   *
   * @return \Drupal\layout_builder\SectionComponent|null
   *   The section component if it is available.
   *
   * @see \Drupal\layout_builder\QuickEditIntegration::entityViewAlter()
   * @see \Drupal\quickedit\MetadataGenerator::generateFieldMetadata()
   */
  private function getQuickEditSectionComponent() {

    // To determine the Quick Edit view_mode ID we need an originalMode set.
    if ($original_mode = $this
      ->getOriginalMode()) {
      $parts = explode('-', $original_mode);

      // The Quick Edit view mode ID is created by
      // \Drupal\layout_builder\QuickEditIntegration::entityViewAlter()
      // concatenating together the information we need to retrieve the Layout
      // Builder component. It follows the structure prescribed by the
      // documentation of hook_quickedit_render_field().
      if (count($parts) === 6 && $parts[0] === 'layout_builder') {
        list(, $delta, $component_uuid, $entity_id) = QuickEditIntegration::deconstructViewModeId($original_mode);
        $entity = $this
          ->entityTypeManager()
          ->getStorage($this
          ->getTargetEntityTypeId())
          ->load($entity_id);
        $sections = $this
          ->getEntitySections($entity);
        if (isset($sections[$delta])) {
          $component = $sections[$delta]
            ->getComponent($component_uuid);
          $plugin = $component
            ->getPlugin();

          // We only care about FieldBlock because these are only components
          // that provide Quick Edit integration: Quick Edit enables in-place
          // editing of fields of entities, not of anything else.
          if ($plugin instanceof DerivativeInspectionInterface && $plugin
            ->getBaseId() === 'field_block') {
            return $component;
          }
        }
      }
    }
    return NULL;
  }

  /**
   * Gets the component for a given field name if any.
   *
   * @param string $field_name
   *   The field name.
   *
   * @return \Drupal\layout_builder\SectionComponent|null
   *   The section component if it is available.
   */
  private function getSectionComponentForFieldName($field_name) {

    // Loop through every component until the first match is found.
    foreach ($this
      ->getSections() as $section) {
      foreach ($section
        ->getComponents() as $component) {
        $plugin = $component
          ->getPlugin();
        if ($plugin instanceof DerivativeInspectionInterface && $plugin
          ->getBaseId() === 'field_block') {

          // FieldBlock derivative IDs are in the format
          // [entity_type]:[bundle]:[field].
          list(, , $field_block_field_name) = explode(PluginBase::DERIVATIVE_SEPARATOR, $plugin
            ->getDerivativeId());
          if ($field_block_field_name === $field_name) {
            return $component;
          }
        }
      }
    }
    return NULL;
  }

}

Members

Name	Modifiers	Type	Description	Overrides
CacheableDependencyTrait::$cacheContexts	protected	property	Cache contexts.
CacheableDependencyTrait::$cacheMaxAge	protected	property	Cache max-age.
CacheableDependencyTrait::$cacheTags	protected	property	Cache tags.
CacheableDependencyTrait::setCacheability	protected	function	Sets cacheability; useful for value object constructors.
ConfigEntityBase::$isUninstalling	private	property	Whether the config is being deleted by the uninstall process.
ConfigEntityBase::$langcode	protected	property	The language code of the entity's default language.
ConfigEntityBase::$originalId	protected	property	The original ID of the configuration entity.
ConfigEntityBase::$third_party_settings	protected	property	Third party entity settings.
ConfigEntityBase::$trustedData	protected	property	Trust supplied data and not use configuration schema on save.
ConfigEntityBase::$uuid	protected	property	The UUID for this entity.
ConfigEntityBase::$_core	protected	property	Information maintained by Drupal core about configuration.
ConfigEntityBase::addDependency	protected	function	Overrides \Drupal\Core\Entity\DependencyTrait:addDependency().
ConfigEntityBase::createDuplicate	public	function	Creates a duplicate of the entity. Overrides EntityBase::createDuplicate	1
ConfigEntityBase::disable	public	function	Disables the configuration entity. Overrides ConfigEntityInterface::disable	1
ConfigEntityBase::enable	public	function	Enables the configuration entity. Overrides ConfigEntityInterface::enable
ConfigEntityBase::get	public	function	Returns the value of a property. Overrides ConfigEntityInterface::get
ConfigEntityBase::getCacheTagsToInvalidate	public	function	Returns the cache tags that should be used to invalidate caches. Overrides EntityBase::getCacheTagsToInvalidate	1
ConfigEntityBase::getConfigDependencyName	public	function	Gets the configuration dependency name. Overrides EntityBase::getConfigDependencyName
ConfigEntityBase::getConfigManager	protected static	function	Gets the configuration manager.
ConfigEntityBase::getConfigTarget	public	function	Gets the configuration target identifier for the entity. Overrides EntityBase::getConfigTarget
ConfigEntityBase::getDependencies	public	function	Gets the configuration dependencies. Overrides ConfigEntityInterface::getDependencies
ConfigEntityBase::getOriginalId	public	function	Gets the original ID. Overrides EntityBase::getOriginalId
ConfigEntityBase::getThirdPartyProviders	public	function	Gets the list of third parties that store information. Overrides ThirdPartySettingsInterface::getThirdPartyProviders
ConfigEntityBase::getThirdPartySetting	public	function	Gets the value of a third-party setting. Overrides ThirdPartySettingsInterface::getThirdPartySetting
ConfigEntityBase::getThirdPartySettings	public	function	Gets all third-party settings of a given module. Overrides ThirdPartySettingsInterface::getThirdPartySettings
ConfigEntityBase::getTypedConfig	protected	function	Gets the typed config manager.
ConfigEntityBase::hasTrustedData	public	function	Gets whether on not the data is trusted. Overrides ConfigEntityInterface::hasTrustedData
ConfigEntityBase::invalidateTagsOnDelete	protected static	function	Override to never invalidate the individual entities' cache tags; the config system already invalidates them. Overrides EntityBase::invalidateTagsOnDelete
ConfigEntityBase::invalidateTagsOnSave	protected	function	Override to never invalidate the entity's cache tag; the config system already invalidates it. Overrides EntityBase::invalidateTagsOnSave
ConfigEntityBase::isInstallable	public	function	Checks whether this entity is installable. Overrides ConfigEntityInterface::isInstallable	2
ConfigEntityBase::isNew	public	function	Overrides Entity::isNew(). Overrides EntityBase::isNew
ConfigEntityBase::isUninstalling	public	function	Returns whether this entity is being changed during the uninstall process. Overrides ConfigEntityInterface::isUninstalling
ConfigEntityBase::link	public	function	Deprecated way of generating a link to the entity. See toLink(). Overrides EntityBase::link
ConfigEntityBase::preDelete	public static	function	Acts on entities before they are deleted and before hooks are invoked. Overrides EntityBase::preDelete	8
ConfigEntityBase::save	public	function	Saves an entity permanently. Overrides EntityBase::save	1
ConfigEntityBase::set	public	function	Sets the value of a property. Overrides ConfigEntityInterface::set
ConfigEntityBase::setOriginalId	public	function	Sets the original ID. Overrides EntityBase::setOriginalId
ConfigEntityBase::setStatus	public	function	Sets the status of the configuration entity. Overrides ConfigEntityInterface::setStatus
ConfigEntityBase::setThirdPartySetting	public	function	Sets the value of a third-party setting. Overrides ThirdPartySettingsInterface::setThirdPartySetting
ConfigEntityBase::setUninstalling	public	function
ConfigEntityBase::sort	public static	function	Helper callback for uasort() to sort configuration entities by weight and label.	6
ConfigEntityBase::status	public	function	Returns whether the configuration entity is enabled. Overrides ConfigEntityInterface::status	4
ConfigEntityBase::toUrl	public	function	Gets the URL object for the entity. Overrides EntityBase::toUrl
ConfigEntityBase::trustData	public	function	Sets that the data should be trusted. Overrides ConfigEntityInterface::trustData
ConfigEntityBase::unsetThirdPartySetting	public	function	Unsets a third-party setting. Overrides ThirdPartySettingsInterface::unsetThirdPartySetting
ConfigEntityBase::url	public	function	Gets the public URL for this entity. Overrides EntityBase::url
ConfigEntityBase::urlInfo	public	function	Gets the URL object for the entity. Overrides EntityBase::urlInfo
DependencySerializationTrait::$_entityStorages	protected	property	An array of entity type IDs keyed by the property name of their storages.
DependencySerializationTrait::$_serviceIds	protected	property	An array of service IDs keyed by property name used for serialization.
DependencySerializationTrait::__sleep	public	function	Aliased as: traitSleep	1
DependencyTrait::$dependencies	protected	property	The object's dependencies.
DependencyTrait::addDependencies	protected	function	Adds multiple dependencies.
DependencyTrait::addDependency	protected	function	Adds a dependency. Aliased as: addDependencyTrait
EntityBase::$enforceIsNew	protected	property	Boolean indicating whether the entity should be forced to be new.
EntityBase::$entityTypeId	protected	property	The entity type.
EntityBase::$typedData	protected	property	A typed data object wrapping this entity.
EntityBase::access	public	function	Checks data value access. Overrides AccessibleInterface::access	1
EntityBase::bundle	public	function	Gets the bundle of the entity. Overrides EntityInterface::bundle	1
EntityBase::create	public static	function	Constructs a new entity object, without permanently saving it. Overrides EntityInterface::create
EntityBase::delete	public	function	Deletes an entity permanently. Overrides EntityInterface::delete	2
EntityBase::enforceIsNew	public	function	Enforces an entity to be new. Overrides EntityInterface::enforceIsNew
EntityBase::entityManager Deprecated	protected	function	Gets the entity manager.
EntityBase::entityTypeBundleInfo	protected	function	Gets the entity type bundle info service.
EntityBase::entityTypeManager	protected	function	Gets the entity type manager.
EntityBase::getCacheContexts	public	function	The cache contexts associated with this object. Overrides CacheableDependencyTrait::getCacheContexts
EntityBase::getCacheMaxAge	public	function	The maximum age for which this object may be cached. Overrides CacheableDependencyTrait::getCacheMaxAge
EntityBase::getCacheTags	public	function	The cache tags associated with this object. Overrides CacheableDependencyTrait::getCacheTags
EntityBase::getConfigDependencyKey	public	function	Gets the key that is used to store configuration dependencies. Overrides EntityInterface::getConfigDependencyKey
EntityBase::getEntityType	public	function	Gets the entity type definition. Overrides EntityInterface::getEntityType
EntityBase::getEntityTypeId	public	function	Gets the ID of the type of the entity. Overrides EntityInterface::getEntityTypeId
EntityBase::getListCacheTagsToInvalidate	protected	function	The list cache tags to invalidate for this entity.
EntityBase::getTypedData	public	function	Gets a typed data object for this entity object. Overrides EntityInterface::getTypedData
EntityBase::hasLinkTemplate	public	function	Indicates if a link template exists for a given key. Overrides EntityInterface::hasLinkTemplate
EntityBase::language	public	function	Gets the language of the entity. Overrides EntityInterface::language	1
EntityBase::languageManager	protected	function	Gets the language manager.
EntityBase::linkTemplates	protected	function	Gets an array link templates.	1
EntityBase::load	public static	function	Loads an entity. Overrides EntityInterface::load
EntityBase::loadMultiple	public static	function	Loads one or more entities. Overrides EntityInterface::loadMultiple
EntityBase::postCreate	public	function	Acts on a created entity before hooks are invoked. Overrides EntityInterface::postCreate	4
EntityBase::postDelete	public static	function	Acts on deleted entities before the delete hook is invoked. Overrides EntityInterface::postDelete	16
EntityBase::postLoad	public static	function	Acts on loaded entities. Overrides EntityInterface::postLoad	2
EntityBase::preCreate	public static	function	Changes the values of an entity before it is created. Overrides EntityInterface::preCreate	5
EntityBase::referencedEntities	public	function	Gets a list of entities referenced by this entity. Overrides EntityInterface::referencedEntities	1
EntityBase::toLink	public	function	Generates the HTML for a link to this entity. Overrides EntityInterface::toLink
EntityBase::uriRelationships	public	function	Gets a list of URI relationships supported by this entity. Overrides EntityInterface::uriRelationships
EntityBase::urlRouteParameters	protected	function	Gets an array of placeholders for this entity.	2
EntityBase::uuid	public	function	Gets the entity UUID (Universally Unique Identifier). Overrides EntityInterface::uuid	1
EntityBase::uuidGenerator	protected	function	Gets the UUID generator.
EntityDisplayBase::$bundle	protected	property	Bundle to be displayed.
EntityDisplayBase::$content	protected	property	List of component display options, keyed by component name.
EntityDisplayBase::$fieldDefinitions	protected	property	A list of field definitions eligible for configuration in this display.
EntityDisplayBase::$hidden	protected	property	List of components that are set to be hidden.
EntityDisplayBase::$id	protected	property	Unique ID for the config entity.
EntityDisplayBase::$mode	protected	property	View or form mode to be displayed.
EntityDisplayBase::$originalMode	protected	property	The original view or form mode that was requested (case of view/form modes being configured to fall back to the 'default' display).
EntityDisplayBase::$pluginManager	protected	property	The plugin manager used by this entity type.
EntityDisplayBase::$plugins	protected	property	The plugin objects used for this display, keyed by field name.
EntityDisplayBase::$renderer	protected	property	The renderer.
EntityDisplayBase::$status	protected	property	Whether this display is enabled or not. If the entity (form) display is disabled, we'll fall back to the 'default' display. Overrides ConfigEntityBase::$status
EntityDisplayBase::$targetEntityType	protected	property	Entity type to be displayed.
EntityDisplayBase::CUSTOM_MODE		constant	The 'mode' for runtime EntityDisplay objects used to render entities with arbitrary display options rather than a configured view mode or form mode.
EntityDisplayBase::fieldHasDisplayOptions	private	function	Determines if a field has options for a given display.
EntityDisplayBase::getComponents	public	function	Gets the display options for all components. Overrides EntityDisplayInterface::getComponents
EntityDisplayBase::getFieldDefinition	protected	function	Gets the field definition of a field.
EntityDisplayBase::getFieldDefinitions	protected	function	Gets the definitions of the fields that are candidate for display.
EntityDisplayBase::getHighestWeight	public	function	Gets the highest weight of the components in the display. Overrides EntityDisplayInterface::getHighestWeight
EntityDisplayBase::getLogger	protected	function	Provides the 'system' channel logger service.
EntityDisplayBase::getMode	public	function	Gets the view or form mode to be displayed. Overrides EntityDisplayInterface::getMode
EntityDisplayBase::getOriginalMode	public	function	Gets the original view or form mode that was requested. Overrides EntityDisplayInterface::getOriginalMode
EntityDisplayBase::getPluginRemovedDependencies	protected	function	Returns the plugin dependencies being removed.
EntityDisplayBase::getTargetBundle	public	function	Gets the bundle to be displayed. Overrides EntityDisplayInterface::getTargetBundle
EntityDisplayBase::getTargetEntityTypeId	public	function	Gets the entity type for which this display is used. Overrides EntityDisplayInterface::getTargetEntityTypeId
EntityDisplayBase::handleHiddenType Deprecated	protected	function	Handles a component type of 'hidden'.
EntityDisplayBase::id	public	function	Gets the identifier. Overrides EntityBase::id
EntityDisplayBase::init	protected	function	Initializes the display.
EntityDisplayBase::removeComponent	public	function	Sets a component to be hidden. Overrides EntityDisplayInterface::removeComponent
EntityDisplayBase::setTargetBundle	public	function	Sets the bundle to be displayed. Overrides EntityDisplayInterface::setTargetBundle
EntityDisplayBase::toArray	public	function	Gets an array of all property values. Overrides ConfigEntityBase::toArray
EntityDisplayBase::__sleep	public	function	Overrides ConfigEntityBase::__sleep
EntityDisplayBase::__wakeup	public	function	Overrides DependencySerializationTrait::__wakeup
EntityViewDisplay::$displayContext	protected	property	Context in which this entity will be used (e.g. 'view', 'form'). Overrides EntityDisplayBase::$displayContext
EntityViewDisplay::build	public	function	Builds a renderable array for the components of an entity. Overrides EntityViewDisplayInterface::build
EntityViewDisplay::collectRenderDisplay	public static	function	Returns the display object used to render an entity.
EntityViewDisplay::collectRenderDisplays	public static	function	Returns the display objects used to render a set of entities.
EntityViewDisplay::getPluginCollections	public	function	Gets the plugin collections used by this object. Overrides ObjectWithPluginCollectionInterface::getPluginCollections
EntityViewDisplay::getRenderer	public	function	Gets the renderer plugin for a field (e.g. widget, formatter). Overrides EntityDisplayInterface::getRenderer
EntityViewDisplay::postSave	public	function	Acts on a saved entity before the insert or update hook is invoked. Overrides EntityBase::postSave
LayoutBuilderEntityViewDisplay::$entityFieldManager	protected	property	The entity field manager.
LayoutBuilderEntityViewDisplay::addSectionField	protected	function	Adds a layout section field to a given bundle.
LayoutBuilderEntityViewDisplay::buildMultiple	public	function	Builds a renderable array for the components of a set of entities. Overrides EntityViewDisplay::buildMultiple
LayoutBuilderEntityViewDisplay::buildSections	protected	function	Builds the render array for the sections of a given entity.
LayoutBuilderEntityViewDisplay::calculateDependencies	public	function	Calculates dependencies and stores them in the dependency property. Overrides EntityDisplayBase::calculateDependencies
LayoutBuilderEntityViewDisplay::contextRepository	protected	function	Wraps the context repository service.
LayoutBuilderEntityViewDisplay::createCopy	public	function	Creates a duplicate of the entity display object on a different view mode. Overrides EntityDisplayBase::createCopy
LayoutBuilderEntityViewDisplay::disableLayoutBuilder	public	function	Disables the Layout Builder. Overrides LayoutBuilderEnabledInterface::disableLayoutBuilder
LayoutBuilderEntityViewDisplay::enableLayoutBuilder	public	function	Enables the Layout Builder. Overrides LayoutBuilderEnabledInterface::enableLayoutBuilder
LayoutBuilderEntityViewDisplay::getComponent	public	function	Gets the display options set for a component. Overrides EntityDisplayBase::getComponent
LayoutBuilderEntityViewDisplay::getContextsForEntity	protected	function	Gets the available contexts for a given entity.
LayoutBuilderEntityViewDisplay::getDefaultRegion	protected	function	Gets the default region. Overrides EntityDisplayBase::getDefaultRegion
LayoutBuilderEntityViewDisplay::getDefaultSection	protected	function	Gets a default section.
LayoutBuilderEntityViewDisplay::getQuickEditSectionComponent	private	function	Returns the Quick Edit formatter settings.
LayoutBuilderEntityViewDisplay::getRuntimeSections Deprecated	protected	function	Gets the runtime sections for a given entity.
LayoutBuilderEntityViewDisplay::getSectionComponentForFieldName	private	function	Gets the component for a given field name if any.
LayoutBuilderEntityViewDisplay::getSections	public	function	Gets the layout sections. Overrides SectionListInterface::getSections
LayoutBuilderEntityViewDisplay::isCustomMode	protected	function	Indicates if this display is using the '_custom' view mode.
LayoutBuilderEntityViewDisplay::isLayoutBuilderEnabled	public	function	Determines if Layout Builder is enabled. Overrides LayoutBuilderEnabledInterface::isLayoutBuilderEnabled
LayoutBuilderEntityViewDisplay::isOverridable	public	function	Determines if the display allows custom overrides. Overrides LayoutEntityDisplayInterface::isOverridable
LayoutBuilderEntityViewDisplay::label	public	function	@todo Move this upstream in https://www.drupal.org/node/2939931. Overrides EntityBase::label
LayoutBuilderEntityViewDisplay::onDependencyRemoval	public	function	Informs the entity that entities it depends on will be deleted. Overrides EntityDisplayBase::onDependencyRemoval
LayoutBuilderEntityViewDisplay::preSave	public	function	Acts on an entity before the presave hook is invoked. Overrides EntityDisplayBase::preSave
LayoutBuilderEntityViewDisplay::removeSectionField	protected	function	Removes a layout section field if it is no longer needed.
LayoutBuilderEntityViewDisplay::sectionStorageManager	private	function	Gets the section storage manager. Overrides LayoutEntityHelperTrait::sectionStorageManager
LayoutBuilderEntityViewDisplay::setComponent	public	function	Sets the display options for a component. Overrides EntityDisplayBase::setComponent
LayoutBuilderEntityViewDisplay::setOverridable	public	function	Sets the display to allow or disallow overrides. Overrides LayoutEntityDisplayInterface::setOverridable
LayoutBuilderEntityViewDisplay::setSections	protected	function	Stores the information for all sections. Overrides SectionStorageTrait::setSections
LayoutBuilderEntityViewDisplay::__construct	public	function	Constructs an Entity object. Overrides EntityViewDisplay::__construct
LayoutEntityHelperTrait::$sectionStorageManager	protected	property	The section storage manager.	1
LayoutEntityHelperTrait::getEntitySections	protected	function	Gets the sections for an entity if any.
LayoutEntityHelperTrait::getInlineBlockComponents	protected	function	Gets components that have Inline Block plugins.
LayoutEntityHelperTrait::getInlineBlockRevisionIdsInSections	protected	function	Gets revision IDs for layout sections.
LayoutEntityHelperTrait::getSectionStorageForEntity	protected	function	Gets the section storage for an entity.
LayoutEntityHelperTrait::isEntityUsingFieldOverride Deprecated	protected	function	Determines if an entity is using a field for the layout override.
LayoutEntityHelperTrait::isLayoutCompatibleEntity	protected	function	Determines if an entity can have a layout.
LayoutEntityHelperTrait::originalEntityUsesDefaultStorage	protected	function	Determines if the original entity used the default section storage.
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
RefinableCacheableDependencyTrait::addCacheableDependency	public	function		1
RefinableCacheableDependencyTrait::addCacheContexts	public	function
RefinableCacheableDependencyTrait::addCacheTags	public	function
RefinableCacheableDependencyTrait::mergeCacheMaxAge	public	function
SectionStorageTrait::addBlankSection	protected	function	Adds a blank section to the list.
SectionStorageTrait::appendSection	public	function
SectionStorageTrait::count	public	function
SectionStorageTrait::getSection	public	function
SectionStorageTrait::hasBlankSection	protected	function	Indicates if this section list contains a blank section.
SectionStorageTrait::hasSection	protected	function	Indicates if there is a section at the specified delta.
SectionStorageTrait::insertSection	public	function
SectionStorageTrait::removeAllSections	public	function
SectionStorageTrait::removeSection	public	function
SectionStorageTrait::setSection	protected	function	Sets the section for the given delta on the display.
SectionStorageTrait::__clone	public	function	Magic method: Implements a deep clone.
SynchronizableEntityTrait::$isSyncing	protected	property	Whether this entity is being created, updated or deleted through a synchronization process.
SynchronizableEntityTrait::isSyncing	public	function
SynchronizableEntityTrait::setSyncing	public	function

You are here

class LayoutBuilderEntityViewDisplay in Drupal 8

Hierarchy

File

Namespace

Members

API Navigation