class Page in Drupal 8

The plugin that handles a full page.

Plugin annotation

@ViewsDisplay(
  id = "page",
  title = @Translation("Page"),
  help = @Translation("Display the view as a page, with a URL and menu links."),
  uses_menu_links = TRUE,
  uses_route = TRUE,
  contextual_links_locations = {"page"},
  theme = "views_view",
  admin = @Translation("Page")
)

Hierarchy

• class \Drupal\Component\Plugin\PluginBase implements DerivativeInspectionInterface, PluginInspectionInterface
  • class \Drupal\Core\Plugin\PluginBase uses DependencySerializationTrait, MessengerTrait, StringTranslationTrait
    • class \Drupal\views\Plugin\views\PluginBase implements DependentPluginInterface, ContainerFactoryPluginInterface, TrustedCallbackInterface, ViewsPluginInterface
      • class \Drupal\views\Plugin\views\display\DisplayPluginBase implements DependentPluginInterface, DisplayPluginInterface uses PluginDependencyTrait
        • class \Drupal\views\Plugin\views\display\PathPluginBase implements DisplayMenuInterface, DisplayRouterInterface uses UrlGeneratorTrait
          • class \Drupal\views\Plugin\views\display\Page

Related topics

Views display plugins

Plugins to handle the overall display of views.

4 files declare their use of Page

PageTest.php in core/modules/views/tests/src/Unit/Plugin/display/PageTest.php

ViewExecutableTest.php in core/modules/views/tests/src/Kernel/ViewExecutableTest.php

ViewPageController.php in core/modules/views/src/Routing/ViewPageController.php

ViewStorageTest.php in core/modules/views/tests/src/Kernel/ViewStorageTest.php

161 string references to 'Page'

ArgumentDefaultTest::testArgumentDefaultNode in core/modules/views/tests/src/Functional/Plugin/ArgumentDefaultTest.php

Test node default argument.

book_views_data in core/modules/book/book.views.inc

Implements hook_views_data().

ConditionFormTest::testConfigForm in core/modules/system/tests/src/Functional/Condition/ConditionFormTest.php

Submit the condition_node_type_test_form to test condition forms.

ContentModerationAccessTest::setUp in core/modules/content_moderation/tests/src/Kernel/ContentModerationAccessTest.php

ContentTranslationEntityBundleUITest::testContentTypeUI in core/modules/content_translation/tests/src/Functional/ContentTranslationEntityBundleUITest.php

Tests content types default translation behavior.

... See full list

File

core/modules/views/src/Plugin/views/display/Page.php, line 29

Namespace

Drupal\views\Plugin\views\display

class Page extends PathPluginBase {

  /**
   * The current page render array.
   *
   * @var array
   */
  protected static $pageRenderArray;

  /**
   * Whether the display allows attachments.
   *
   * @var bool
   */
  protected $usesAttachments = TRUE;

  /**
   * The menu storage.
   *
   * @var \Drupal\Core\Entity\EntityStorageInterface
   */
  protected $menuStorage;

  /**
   * Constructs a Page object.
   *
   * @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\Core\Routing\RouteProviderInterface $route_provider
   *   The route provider.
   * @param \Drupal\Core\State\StateInterface $state
   *   The state key value store.
   * @param \Drupal\Core\Entity\EntityStorageInterface $menu_storage
   *   The menu storage.
   */
  public function __construct(array $configuration, $plugin_id, $plugin_definition, RouteProviderInterface $route_provider, StateInterface $state, EntityStorageInterface $menu_storage) {
    parent::__construct($configuration, $plugin_id, $plugin_definition, $route_provider, $state);
    $this->menuStorage = $menu_storage;
  }

  /**
   * {@inheritdoc}
   */
  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
    return new static($configuration, $plugin_id, $plugin_definition, $container
      ->get('router.route_provider'), $container
      ->get('state'), $container
      ->get('entity_type.manager')
      ->getStorage('menu'));
  }

  /**
   * {@inheritdoc}
   */
  protected function getRoute($view_id, $display_id) {
    $route = parent::getRoute($view_id, $display_id);

    // Explicitly set HTML as the format for Page displays.
    $route
      ->setRequirement('_format', 'html');
    return $route;
  }

  /**
   * Sets the current page views render array.
   *
   * @param array $element
   *   (optional) A render array. If not specified the previous element is
   *   returned.
   *
   * @return array
   *   The page render array.
   */
  public static function &setPageRenderArray(array &$element = NULL) {
    if (isset($element)) {
      static::$pageRenderArray =& $element;
    }
    return static::$pageRenderArray;
  }

  /**
   * Gets the current views page render array.
   *
   * @return array
   *   The page render array.
   */
  public static function &getPageRenderArray() {
    return static::$pageRenderArray;
  }

  /**
   * {@inheritdoc}
   */
  protected function defineOptions() {
    $options = parent::defineOptions();
    $options['menu'] = [
      'contains' => [
        'type' => [
          'default' => 'none',
        ],
        'title' => [
          'default' => '',
        ],
        'description' => [
          'default' => '',
        ],
        'weight' => [
          'default' => 0,
        ],
        'enabled' => [
          'default' => TRUE,
        ],
        'menu_name' => [
          'default' => 'main',
        ],
        'parent' => [
          'default' => '',
        ],
        'context' => [
          'default' => '',
        ],
        'expanded' => [
          'default' => FALSE,
        ],
      ],
    ];
    $options['tab_options'] = [
      'contains' => [
        'type' => [
          'default' => 'none',
        ],
        'title' => [
          'default' => '',
        ],
        'description' => [
          'default' => '',
        ],
        'weight' => [
          'default' => 0,
        ],
      ],
    ];
    return $options;
  }

  /**
   * {@inheritdoc}
   */
  public static function buildBasicRenderable($view_id, $display_id, array $args = [], Route $route = NULL) {
    $build = parent::buildBasicRenderable($view_id, $display_id, $args);
    if ($route) {
      $build['#view_id'] = $route
        ->getDefault('view_id');
      $build['#view_display_plugin_id'] = $route
        ->getOption('_view_display_plugin_id');
      $build['#view_display_show_admin_links'] = $route
        ->getOption('_view_display_show_admin_links');
    }
    else {
      throw new \BadFunctionCallException('Missing route parameters.');
    }
    return $build;
  }

  /**
   * {@inheritdoc}
   */
  public function execute() {
    parent::execute();

    // And now render the view.
    $render = $this->view
      ->render();

    // First execute the view so it's possible to get tokens for the title.
    // And the title, which is much easier.
    // @todo Figure out how to support custom response objects. Maybe for pages
    //   it should be dropped.
    if (is_array($render)) {
      $render += [
        '#title' => [
          '#markup' => $this->view
            ->getTitle(),
          '#allowed_tags' => Xss::getHtmlTagList(),
        ],
      ];
    }
    return $render;
  }

  /**
   * {@inheritdoc}
   */
  public function optionsSummary(&$categories, &$options) {
    parent::optionsSummary($categories, $options);
    $menu = $this
      ->getOption('menu');
    if (!is_array($menu)) {
      $menu = [
        'type' => 'none',
      ];
    }
    switch ($menu['type']) {
      case 'none':
      default:
        $menu_str = $this
          ->t('No menu');
        break;
      case 'normal':
        $menu_str = $this
          ->t('Normal: @title', [
          '@title' => $menu['title'],
        ]);
        break;
      case 'tab':
      case 'default tab':
        $menu_str = $this
          ->t('Tab: @title', [
          '@title' => $menu['title'],
        ]);
        break;
    }
    $options['menu'] = [
      'category' => 'page',
      'title' => $this
        ->t('Menu'),
      'value' => views_ui_truncate($menu_str, 24),
    ];

    // This adds a 'Settings' link to the style_options setting if the style
    // has options.
    if ($menu['type'] == 'default tab') {
      $options['menu']['setting'] = $this
        ->t('Parent menu item');
      $options['menu']['links']['tab_options'] = $this
        ->t('Change settings for the parent menu');
    }
  }

  /**
   * {@inheritdoc}
   */
  public function buildOptionsForm(&$form, FormStateInterface $form_state) {
    parent::buildOptionsForm($form, $form_state);
    switch ($form_state
      ->get('section')) {
      case 'menu':
        $form['#title'] .= $this
          ->t('Menu item entry');
        $form['menu'] = [
          '#prefix' => '<div class="clearfix">',
          '#suffix' => '</div>',
          '#tree' => TRUE,
        ];
        $menu = $this
          ->getOption('menu');
        if (empty($menu)) {
          $menu = [
            'type' => 'none',
            'title' => '',
            'weight' => 0,
            'expanded' => FALSE,
          ];
        }
        $form['menu']['type'] = [
          '#prefix' => '<div class="views-left-30">',
          '#suffix' => '</div>',
          '#title' => $this
            ->t('Type'),
          '#type' => 'radios',
          '#options' => [
            'none' => $this
              ->t('No menu entry'),
            'normal' => $this
              ->t('Normal menu entry'),
            'tab' => $this
              ->t('Menu tab'),
            'default tab' => $this
              ->t('Default menu tab'),
          ],
          '#default_value' => $menu['type'],
        ];
        $form['menu']['title'] = [
          '#prefix' => '<div class="views-left-50">',
          '#title' => $this
            ->t('Menu link title'),
          '#type' => 'textfield',
          '#default_value' => $menu['title'],
          '#states' => [
            'visible' => [
              [
                ':input[name="menu[type]"]' => [
                  'value' => 'normal',
                ],
              ],
              [
                ':input[name="menu[type]"]' => [
                  'value' => 'tab',
                ],
              ],
              [
                ':input[name="menu[type]"]' => [
                  'value' => 'default tab',
                ],
              ],
            ],
          ],
        ];
        $form['menu']['description'] = [
          '#title' => $this
            ->t('Description'),
          '#type' => 'textfield',
          '#default_value' => $menu['description'],
          '#description' => $this
            ->t("Shown when hovering over the menu link."),
          '#states' => [
            'visible' => [
              [
                ':input[name="menu[type]"]' => [
                  'value' => 'normal',
                ],
              ],
              [
                ':input[name="menu[type]"]' => [
                  'value' => 'tab',
                ],
              ],
              [
                ':input[name="menu[type]"]' => [
                  'value' => 'default tab',
                ],
              ],
            ],
          ],
        ];
        $form['menu']['expanded'] = [
          '#title' => $this
            ->t('Show as expanded'),
          '#type' => 'checkbox',
          '#default_value' => !empty($menu['expanded']),
          '#description' => $this
            ->t('If selected and this menu link has children, the menu will always appear expanded.'),
        ];

        // Only display the parent selector if Menu UI module is enabled.
        $menu_parent = $menu['menu_name'] . ':' . $menu['parent'];
        if (\Drupal::moduleHandler()
          ->moduleExists('menu_ui')) {
          $menu_link = 'views_view:views.' . $form_state
            ->get('view')
            ->id() . '.' . $form_state
            ->get('display_id');
          $form['menu']['parent'] = \Drupal::service('menu.parent_form_selector')
            ->parentSelectElement($menu_parent, $menu_link);
          $form['menu']['parent'] += [
            '#title' => $this
              ->t('Parent'),
            '#description' => $this
              ->t('The maximum depth for a link and all its children is fixed. Some menu links may not be available as parents if selecting them would exceed this limit.'),
            '#attributes' => [
              'class' => [
                'menu-title-select',
              ],
            ],
            '#states' => [
              'visible' => [
                [
                  ':input[name="menu[type]"]' => [
                    'value' => 'normal',
                  ],
                ],
                [
                  ':input[name="menu[type]"]' => [
                    'value' => 'tab',
                  ],
                ],
              ],
            ],
          ];
        }
        else {
          $form['menu']['parent'] = [
            '#type' => 'value',
            '#value' => $menu_parent,
          ];
          $form['menu']['markup'] = [
            '#markup' => $this
              ->t('Menu selection requires the activation of Menu UI module.'),
          ];
        }
        $form['menu']['weight'] = [
          '#title' => $this
            ->t('Weight'),
          '#type' => 'textfield',
          '#default_value' => isset($menu['weight']) ? $menu['weight'] : 0,
          '#description' => $this
            ->t('In the menu, the heavier links will sink and the lighter links will be positioned nearer the top.'),
          '#states' => [
            'visible' => [
              [
                ':input[name="menu[type]"]' => [
                  'value' => 'normal',
                ],
              ],
              [
                ':input[name="menu[type]"]' => [
                  'value' => 'tab',
                ],
              ],
              [
                ':input[name="menu[type]"]' => [
                  'value' => 'default tab',
                ],
              ],
            ],
          ],
        ];
        $form['menu']['context'] = [
          '#title' => $this
            ->t('Context'),
          '#suffix' => '</div>',
          '#type' => 'checkbox',
          '#default_value' => !empty($menu['context']),
          '#description' => $this
            ->t('Displays the link in contextual links'),
          '#states' => [
            'visible' => [
              ':input[name="menu[type]"]' => [
                'value' => 'tab',
              ],
            ],
          ],
        ];
        break;
      case 'tab_options':
        $form['#title'] .= $this
          ->t('Default tab options');
        $tab_options = $this
          ->getOption('tab_options');
        if (empty($tab_options)) {
          $tab_options = [
            'type' => 'none',
            'title' => '',
            'weight' => 0,
          ];
        }
        $form['tab_markup'] = [
          '#markup' => '<div class="js-form-item form-item description">' . $this
            ->t('When providing a menu item as a tab, Drupal needs to know what the parent menu item of that tab will be. Sometimes the parent will already exist, but other times you will need to have one created. The path of a parent item will always be the same path with the last part left off. i.e, if the path to this view is <em>foo/bar/baz</em>, the parent path would be <em>foo/bar</em>.') . '</div>',
        ];
        $form['tab_options'] = [
          '#prefix' => '<div class="clearfix">',
          '#suffix' => '</div>',
          '#tree' => TRUE,
        ];
        $form['tab_options']['type'] = [
          '#prefix' => '<div class="views-left-25">',
          '#suffix' => '</div>',
          '#title' => $this
            ->t('Parent menu item'),
          '#type' => 'radios',
          '#options' => [
            'none' => $this
              ->t('Already exists'),
            'normal' => $this
              ->t('Normal menu item'),
            'tab' => $this
              ->t('Menu tab'),
          ],
          '#default_value' => $tab_options['type'],
        ];
        $form['tab_options']['title'] = [
          '#prefix' => '<div class="views-left-75">',
          '#title' => $this
            ->t('Title'),
          '#type' => 'textfield',
          '#default_value' => $tab_options['title'],
          '#description' => $this
            ->t('If creating a parent menu item, enter the title of the item.'),
          '#states' => [
            'visible' => [
              [
                ':input[name="tab_options[type]"]' => [
                  'value' => 'normal',
                ],
              ],
              [
                ':input[name="tab_options[type]"]' => [
                  'value' => 'tab',
                ],
              ],
            ],
          ],
        ];
        $form['tab_options']['description'] = [
          '#title' => $this
            ->t('Description'),
          '#type' => 'textfield',
          '#default_value' => $tab_options['description'],
          '#description' => $this
            ->t('If creating a parent menu item, enter the description of the item.'),
          '#states' => [
            'visible' => [
              [
                ':input[name="tab_options[type]"]' => [
                  'value' => 'normal',
                ],
              ],
              [
                ':input[name="tab_options[type]"]' => [
                  'value' => 'tab',
                ],
              ],
            ],
          ],
        ];
        $form['tab_options']['weight'] = [
          '#suffix' => '</div>',
          '#title' => $this
            ->t('Tab weight'),
          '#type' => 'textfield',
          '#default_value' => $tab_options['weight'],
          '#size' => 5,
          '#description' => $this
            ->t('If the parent menu item is a tab, enter the weight of the tab. Heavier tabs will sink and the lighter tabs will be positioned nearer to the first menu item.'),
          '#states' => [
            'visible' => [
              ':input[name="tab_options[type]"]' => [
                'value' => 'tab',
              ],
            ],
          ],
        ];
        break;
    }
  }

  /**
   * {@inheritdoc}
   */
  public function validateOptionsForm(&$form, FormStateInterface $form_state) {
    parent::validateOptionsForm($form, $form_state);
    if ($form_state
      ->get('section') == 'menu') {
      $path = $this
        ->getOption('path');
      $menu_type = $form_state
        ->getValue([
        'menu',
        'type',
      ]);
      if ($menu_type == 'normal' && strpos($path, '%') !== FALSE) {
        $form_state
          ->setError($form['menu']['type'], $this
          ->t('Views cannot create normal menu items for paths with a % in them.'));
      }
      if ($menu_type == 'default tab' || $menu_type == 'tab') {
        $bits = explode('/', $path);
        $last = array_pop($bits);
        if ($last == '%') {
          $form_state
            ->setError($form['menu']['type'], $this
            ->t('A display whose path ends with a % cannot be a tab.'));
        }
      }
      if ($menu_type != 'none' && $form_state
        ->isValueEmpty([
        'menu',
        'title',
      ])) {
        $form_state
          ->setError($form['menu']['title'], $this
          ->t('Title is required for this menu type.'));
      }
    }
  }

  /**
   * {@inheritdoc}
   */
  public function submitOptionsForm(&$form, FormStateInterface $form_state) {
    parent::submitOptionsForm($form, $form_state);
    switch ($form_state
      ->get('section')) {
      case 'menu':
        $menu = $form_state
          ->getValue('menu');
        list($menu['menu_name'], $menu['parent']) = explode(':', $menu['parent'], 2);
        $this
          ->setOption('menu', $menu);

        // send ajax form to options page if we use it.
        if ($form_state
          ->getValue([
          'menu',
          'type',
        ]) == 'default tab') {
          $form_state
            ->get('view')
            ->addFormToStack('display', $this->display['id'], 'tab_options');
        }
        break;
      case 'tab_options':
        $this
          ->setOption('tab_options', $form_state
          ->getValue('tab_options'));
        break;
    }
  }

  /**
   * {@inheritdoc}
   */
  public function validate() {
    $errors = parent::validate();
    $menu = $this
      ->getOption('menu');
    if (!empty($menu['type']) && $menu['type'] != 'none' && empty($menu['title'])) {
      $errors[] = $this
        ->t('Display @display is set to use a menu but the menu link text is not set.', [
        '@display' => $this->display['display_title'],
      ]);
    }
    if ($menu['type'] == 'default tab') {
      $tab_options = $this
        ->getOption('tab_options');
      if (!empty($tab_options['type']) && $tab_options['type'] != 'none' && empty($tab_options['title'])) {
        $errors[] = $this
          ->t('Display @display is set to use a parent menu but the parent menu link text is not set.', [
          '@display' => $this->display['display_title'],
        ]);
      }
    }
    return $errors;
  }

  /**
   * {@inheritdoc}
   */
  public function getArgumentText() {
    return [
      'filter value not present' => $this
        ->t('When the filter value is <em>NOT</em> in the URL'),
      'filter value present' => $this
        ->t('When the filter value <em>IS</em> in the URL or a default is provided'),
      'description' => $this
        ->t('The contextual filter values are provided by the URL.'),
    ];
  }

  /**
   * {@inheritdoc}
   */
  public function getPagerText() {
    return [
      'items per page title' => $this
        ->t('Items per page'),
      'items per page description' => $this
        ->t('Enter 0 for no limit.'),
    ];
  }

  /**
   * {@inheritdoc}
   */
  public function calculateDependencies() {
    $dependencies = parent::calculateDependencies();
    $menu = $this
      ->getOption('menu');
    if ($menu['type'] === 'normal' && ($menu_entity = $this->menuStorage
      ->load($menu['menu_name']))) {
      $dependencies[$menu_entity
        ->getConfigDependencyKey()][] = $menu_entity
        ->getConfigDependencyName();
    }
    return $dependencies;
  }

}

Members

Name	Modifiers	Type	Description	Overrides
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		1
DependencySerializationTrait::__wakeup	public	function		2
DependencyTrait::$dependencies	protected	property	The object's dependencies.
DependencyTrait::addDependencies	protected	function	Adds multiple dependencies.
DependencyTrait::addDependency	protected	function	Adds a dependency.
DisplayPluginBase::$display	public	property	The display information coming directly from the view entity.
DisplayPluginBase::$extenders	protected	property	Stores all available display extenders.
DisplayPluginBase::$handlers	public	property	An array of instantiated handlers used in this display.
DisplayPluginBase::$output	public	property	Stores the rendered output of the display.
DisplayPluginBase::$plugins	protected	property	An array of instantiated plugins used in this display.
DisplayPluginBase::$unpackOptions	protected static	property	Static cache for unpackOptions, but not if we are in the UI.
DisplayPluginBase::$usesAJAX	protected	property	Whether the display allows the use of AJAX or not.	2
DisplayPluginBase::$usesAreas	protected	property	Whether the display allows area plugins.	2
DisplayPluginBase::$usesMore	protected	property	Whether the display allows the use of a 'more' link or not.	1
DisplayPluginBase::$usesOptions	protected	property	Denotes whether the plugin has an additional options form. Overrides PluginBase::$usesOptions	1
DisplayPluginBase::$usesPager	protected	property	Whether the display allows the use of a pager or not.	4
DisplayPluginBase::$view	public	property	The top object of a view. Overrides PluginBase::$view
DisplayPluginBase::acceptAttachments	public	function	Determines whether this display can use attachments. Overrides DisplayPluginInterface::acceptAttachments
DisplayPluginBase::access	public	function	Determines if the user has access to this display of the view. Overrides DisplayPluginInterface::access
DisplayPluginBase::ajaxEnabled	public	function	Whether the display is actually using AJAX or not. Overrides DisplayPluginInterface::ajaxEnabled
DisplayPluginBase::applyDisplayCachablityMetadata Deprecated	protected	function	Applies the cacheability of the current display to the given render array.
DisplayPluginBase::applyDisplayCacheabilityMetadata	protected	function	Applies the cacheability of the current display to the given render array.
DisplayPluginBase::attachTo	public	function	Allows displays to attach to other views. Overrides DisplayPluginInterface::attachTo	2
DisplayPluginBase::buildRenderable	public	function	Builds a renderable array of the view. Overrides DisplayPluginInterface::buildRenderable	1
DisplayPluginBase::buildRenderingLanguageOptions	protected	function	Returns the available rendering strategies for language-aware entities.
DisplayPluginBase::calculateCacheMetadata	public	function	Calculates the display's cache metadata by inspecting each handler/plugin. Overrides DisplayPluginInterface::calculateCacheMetadata
DisplayPluginBase::defaultableSections	public	function	Lists the 'defaultable' sections and what items each section contains. Overrides DisplayPluginInterface::defaultableSections	1
DisplayPluginBase::destroy	public	function	Clears a plugin. Overrides PluginBase::destroy
DisplayPluginBase::displaysExposed	public	function	Determines if this display should display the exposed filters widgets. Overrides DisplayPluginInterface::displaysExposed	2
DisplayPluginBase::elementPreRender	public	function	#pre_render callback for view display rendering. Overrides DisplayPluginInterface::elementPreRender
DisplayPluginBase::getAllHandlers	protected	function	Gets all the handlers used by the display.
DisplayPluginBase::getAllPlugins	protected	function	Gets all the plugins used by the display.
DisplayPluginBase::getArgumentsTokens	public	function	Returns to tokens for arguments. Overrides DisplayPluginInterface::getArgumentsTokens
DisplayPluginBase::getAttachedDisplays	public	function	Find out all displays which are attached to this display. Overrides DisplayPluginInterface::getAttachedDisplays
DisplayPluginBase::getCacheMetadata	public	function	Gets the cache metadata. Overrides DisplayPluginInterface::getCacheMetadata
DisplayPluginBase::getExtenders	public	function	Gets the display extenders. Overrides DisplayPluginInterface::getExtenders
DisplayPluginBase::getFieldLabels	public	function	Retrieves a list of fields for the current display. Overrides DisplayPluginInterface::getFieldLabels
DisplayPluginBase::getHandler	public	function	Get the handler object for a single handler. Overrides DisplayPluginInterface::getHandler
DisplayPluginBase::getHandlers	public	function	Get a full array of handlers for $type. This caches them. Overrides DisplayPluginInterface::getHandlers
DisplayPluginBase::getLinkDisplay	public	function	Returns the ID of the display to use when making links. Overrides DisplayPluginInterface::getLinkDisplay
DisplayPluginBase::getMoreUrl	protected	function	Get the more URL for this view.
DisplayPluginBase::getOption	public	function	Gets an option, from this display or the default display. Overrides DisplayPluginInterface::getOption
DisplayPluginBase::getPlugin	public	function	Get the instance of a plugin, for example style or row. Overrides DisplayPluginInterface::getPlugin
DisplayPluginBase::getRoutedDisplay	public	function	Points to the display which can be linked by this display. Overrides DisplayPluginInterface::getRoutedDisplay
DisplayPluginBase::getSpecialBlocks	public	function	Provides the block system with any exposed widget blocks for this display. Overrides DisplayPluginInterface::getSpecialBlocks
DisplayPluginBase::getType	public	function	Returns the display type that this display requires. Overrides DisplayPluginInterface::getType	4
DisplayPluginBase::getUrl	public	function	Returns a URL to $this display or its configured linked display. Overrides DisplayPluginInterface::getUrl
DisplayPluginBase::initDisplay	public	function	Initializes the display plugin. Overrides DisplayPluginInterface::initDisplay	1
DisplayPluginBase::isBaseTableTranslatable	protected	function	Returns whether the base table is of a translatable entity type.
DisplayPluginBase::isDefaultDisplay	public	function	Determines if this display is the 'default' display. Overrides DisplayPluginInterface::isDefaultDisplay	1
DisplayPluginBase::isDefaulted	public	function	Determines if an option is set to use the default or current display. Overrides DisplayPluginInterface::isDefaulted
DisplayPluginBase::isEnabled	public	function	Whether the display is enabled. Overrides DisplayPluginInterface::isEnabled
DisplayPluginBase::isIdentifierUnique	public	function	Checks if the provided identifier is unique. Overrides DisplayPluginInterface::isIdentifierUnique
DisplayPluginBase::isMoreEnabled	public	function	Whether the display is using the 'more' link or not. Overrides DisplayPluginInterface::isMoreEnabled
DisplayPluginBase::isPagerEnabled	public	function	Whether the display is using a pager or not. Overrides DisplayPluginInterface::isPagerEnabled
DisplayPluginBase::mergeDefaults	public	function	Merges default values for all plugin types. Overrides DisplayPluginInterface::mergeDefaults
DisplayPluginBase::mergeHandler	protected	function	Merges handlers default values.
DisplayPluginBase::mergePlugin	protected	function	Merges plugins default values.
DisplayPluginBase::newDisplay	public	function	Reacts on adding a display. Overrides DisplayPluginInterface::newDisplay	1
DisplayPluginBase::optionLink	public	function	Returns a link to a section of a form. Overrides DisplayPluginInterface::optionLink
DisplayPluginBase::optionsOverride	public	function	If override/revert was clicked, perform the proper toggle. Overrides DisplayPluginInterface::optionsOverride
DisplayPluginBase::outputIsEmpty	public	function	Is the output of the view empty. Overrides DisplayPluginInterface::outputIsEmpty
DisplayPluginBase::overrideOption	public	function	Set an option and force it to be an override. Overrides DisplayPluginInterface::overrideOption
DisplayPluginBase::preExecute	public	function	Sets up any variables on the view prior to execution. Overrides DisplayPluginInterface::preExecute
DisplayPluginBase::preview	public	function	Renders the display for the purposes of a live preview. Overrides DisplayPluginInterface::preview	3
DisplayPluginBase::query	public	function	Add anything to the query that we might need to. Overrides PluginBase::query	1
DisplayPluginBase::render	public	function	Renders this display. Overrides DisplayPluginInterface::render	3
DisplayPluginBase::renderArea	public	function	Renders one of the available areas. Overrides DisplayPluginInterface::renderArea
DisplayPluginBase::renderFilters	public	function	Does nothing (obsolete function). Overrides DisplayPluginInterface::renderFilters
DisplayPluginBase::renderMoreLink	public	function	Renders the 'more' link. Overrides DisplayPluginInterface::renderMoreLink
DisplayPluginBase::renderPager	public	function	Checks to see if the display plugins support pager rendering. Overrides DisplayPluginInterface::renderPager	1
DisplayPluginBase::setOption	public	function	Sets an option, on this display or the default display. Overrides DisplayPluginInterface::setOption
DisplayPluginBase::setOverride	public	function	Flip the override setting for the given section. Overrides DisplayPluginInterface::setOverride
DisplayPluginBase::trustedCallbacks	public static	function	Lists the trusted callbacks provided by the implementing class. Overrides PluginBase::trustedCallbacks
DisplayPluginBase::useGroupBy	public	function	Does the display have groupby enabled? Overrides DisplayPluginInterface::useGroupBy
DisplayPluginBase::useMoreAlways	public	function	Should the enabled display more link be shown when no more items? Overrides DisplayPluginInterface::useMoreAlways
DisplayPluginBase::useMoreText	public	function	Does the display have custom link text? Overrides DisplayPluginInterface::useMoreText
DisplayPluginBase::usesAJAX	public	function	Whether the display allows the use of AJAX or not. Overrides DisplayPluginInterface::usesAJAX	2
DisplayPluginBase::usesAreas	public	function	Returns whether the display can use areas. Overrides DisplayPluginInterface::usesAreas	2
DisplayPluginBase::usesAttachments	public	function	Returns whether the display can use attachments. Overrides DisplayPluginInterface::usesAttachments	6
DisplayPluginBase::usesExposed	public	function	Determines if this display uses exposed filters. Overrides DisplayPluginInterface::usesExposed	4
DisplayPluginBase::usesExposedFormInBlock	public	function	Checks to see if the display can put the exposed form in a block. Overrides DisplayPluginInterface::usesExposedFormInBlock
DisplayPluginBase::usesFields	public	function	Determines if the display's style uses fields. Overrides DisplayPluginInterface::usesFields
DisplayPluginBase::usesLinkDisplay	public	function	Checks to see if the display has some need to link to another display. Overrides DisplayPluginInterface::usesLinkDisplay	1
DisplayPluginBase::usesMore	public	function	Whether the display allows the use of a 'more' link or not. Overrides DisplayPluginInterface::usesMore	1
DisplayPluginBase::usesPager	public	function	Whether the display allows the use of a pager or not. Overrides DisplayPluginInterface::usesPager	4
DisplayPluginBase::viewExposedFormBlocks	public	function	Renders the exposed form as block. Overrides DisplayPluginInterface::viewExposedFormBlocks
MessengerTrait::$messenger	protected	property	The messenger.	29
MessengerTrait::messenger	public	function	Gets the messenger.	29
MessengerTrait::setMessenger	public	function	Sets the messenger.
Page::$menuStorage	protected	property	The menu storage.
Page::$pageRenderArray	protected static	property	The current page render array.
Page::$usesAttachments	protected	property	Whether the display allows attachments. Overrides DisplayPluginBase::$usesAttachments
Page::buildBasicRenderable	public static	function	Builds a basic render array which can be properly render cached. Overrides DisplayPluginBase::buildBasicRenderable
Page::buildOptionsForm	public	function	Provide a form to edit options for this plugin. Overrides PathPluginBase::buildOptionsForm
Page::calculateDependencies	public	function	Calculates dependencies for the configured plugin. Overrides DisplayPluginBase::calculateDependencies
Page::create	public static	function	Creates an instance of the plugin. Overrides PathPluginBase::create
Page::defineOptions	protected	function	Overrides \Drupal\views\Plugin\views\display\DisplayPluginBase:defineOptions(). Overrides PathPluginBase::defineOptions
Page::execute	public	function	Executes the view and returns data in the format required. Overrides PathPluginBase::execute
Page::getArgumentText	public	function	Provides help text for the arguments. Overrides DisplayPluginBase::getArgumentText
Page::getPageRenderArray	public static	function	Gets the current views page render array.
Page::getPagerText	public	function	Provides help text for pagers. Overrides DisplayPluginBase::getPagerText
Page::getRoute	protected	function	Generates a route entry for a given view and display. Overrides PathPluginBase::getRoute
Page::optionsSummary	public	function	Provides the default summary for options in the views UI. Overrides PathPluginBase::optionsSummary
Page::setPageRenderArray	public static	function	Sets the current page views render array.
Page::submitOptionsForm	public	function	Handle any special handling on the validate form. Overrides PathPluginBase::submitOptionsForm
Page::validate	public	function	Validate that the plugin is correct and can be saved. Overrides PathPluginBase::validate
Page::validateOptionsForm	public	function	Validate the options form. Overrides PathPluginBase::validateOptionsForm
Page::__construct	public	function	Constructs a Page object. Overrides PathPluginBase::__construct
PathPluginBase::$routeProvider	protected	property	The route provider.
PathPluginBase::$state	protected	property	The state key value store.
PathPluginBase::alterRoutes	public	function	Alters a collection of routes and replaces definitions to the view. Overrides DisplayRouterInterface::alterRoutes
PathPluginBase::collectRoutes	public	function	Adds the route entry of a view to the collection. Overrides DisplayRouterInterface::collectRoutes	1
PathPluginBase::getAlteredRouteNames	public	function	Returns the list of routes overridden by Views. Overrides DisplayRouterInterface::getAlteredRouteNames
PathPluginBase::getMenuLinks	public	function	Gets menu links, if this display provides some. Overrides DisplayMenuInterface::getMenuLinks
PathPluginBase::getPath	public	function	Returns the base path to use for this display. Overrides DisplayPluginBase::getPath
PathPluginBase::getRouteName	public	function	Returns the route name for the display. Overrides DisplayRouterInterface::getRouteName
PathPluginBase::getUrlInfo	public	function	Generates a URL to this display. Overrides DisplayRouterInterface::getUrlInfo
PathPluginBase::hasPath	public	function	Checks to see if the display has a 'path' field. Overrides DisplayPluginBase::hasPath
PathPluginBase::isDefaultTabPath	protected	function	Determines if this display's path is a default tab.
PathPluginBase::overrideApplies	protected	function	Determines whether the view overrides the given route.	1
PathPluginBase::overrideAppliesPathAndMethod	protected	function	Determines whether a override for the path and method should happen.
PathPluginBase::remove	public	function	Reacts on deleting a display. Overrides DisplayPluginBase::remove
PathPluginBase::validatePath	protected	function	Validates the path of the display.
PluginBase::$configuration	protected	property	Configuration information passed into the plugin.	1
PluginBase::$definition	public	property	Plugins's definition
PluginBase::$displayHandler	public	property	The display object this plugin is for.
PluginBase::$options	public	property	Options for this plugin will be held here.
PluginBase::$pluginDefinition	protected	property	The plugin implementation definition.	1
PluginBase::$pluginId	protected	property	The plugin_id.
PluginBase::$renderer	protected	property	Stores the render API renderer.	3
PluginBase::DERIVATIVE_SEPARATOR		constant	A string which is used to separate base plugin IDs from the derivative ID.
PluginBase::doFilterByDefinedOptions	protected	function	Do the work to filter out stored options depending on the defined options.
PluginBase::filterByDefinedOptions	public	function	Filter out stored options depending on the defined options. Overrides ViewsPluginInterface::filterByDefinedOptions
PluginBase::getAvailableGlobalTokens	public	function	Returns an array of available token replacements. Overrides ViewsPluginInterface::getAvailableGlobalTokens
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	3
PluginBase::getPluginId	public	function	Gets the plugin_id of the plugin instance. Overrides PluginInspectionInterface::getPluginId
PluginBase::getProvider	public	function	Returns the plugin provider. Overrides ViewsPluginInterface::getProvider
PluginBase::getRenderer	protected	function	Returns the render API renderer.	1
PluginBase::globalTokenForm	public	function	Adds elements for available core tokens to a form. Overrides ViewsPluginInterface::globalTokenForm
PluginBase::globalTokenReplace	public	function	Returns a string with any core tokens replaced. Overrides ViewsPluginInterface::globalTokenReplace
PluginBase::INCLUDE_ENTITY		constant	Include entity row languages when listing languages.
PluginBase::INCLUDE_NEGOTIATED		constant	Include negotiated languages when listing languages.
PluginBase::init	public	function	Initialize the plugin. Overrides ViewsPluginInterface::init	8
PluginBase::isConfigurable	public	function	Determines if the plugin is configurable.
PluginBase::listLanguages	protected	function	Makes an array of languages, optionally including special languages.
PluginBase::pluginTitle	public	function	Return the human readable name of the display. Overrides ViewsPluginInterface::pluginTitle
PluginBase::preRenderAddFieldsetMarkup	public static	function	Moves form elements into fieldsets for presentation purposes. Overrides ViewsPluginInterface::preRenderAddFieldsetMarkup
PluginBase::preRenderFlattenData	public static	function	Flattens the structure of form elements. Overrides ViewsPluginInterface::preRenderFlattenData
PluginBase::queryLanguageSubstitutions	public static	function	Returns substitutions for Views queries for languages.
PluginBase::setOptionDefaults	protected	function	Fills up the options of the plugin with defaults.
PluginBase::summaryTitle	public	function	Returns the summary of the settings in the display. Overrides ViewsPluginInterface::summaryTitle	6
PluginBase::themeFunctions	public	function	Provide a full list of possible theme templates used by this style. Overrides ViewsPluginInterface::themeFunctions	1
PluginBase::unpackOptions	public	function	Unpack options over our existing defaults, drilling down into arrays so that defaults don't get totally blown away. Overrides ViewsPluginInterface::unpackOptions
PluginBase::usesOptions	public	function	Returns the usesOptions property. Overrides ViewsPluginInterface::usesOptions	8
PluginBase::viewsTokenReplace	protected	function	Replaces Views' tokens in a given string. The resulting string will be sanitized with Xss::filterAdmin.	1
PluginBase::VIEWS_QUERY_LANGUAGE_SITE_DEFAULT		constant	Query string to indicate the site default language.
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
StringTranslationTrait::$stringTranslation	protected	property	The string translation service.	1
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.
TrustedCallbackInterface::THROW_EXCEPTION		constant	Untrusted callbacks throw exceptions.
TrustedCallbackInterface::TRIGGER_SILENCED_DEPRECATION		constant	Untrusted callbacks trigger silenced E_USER_DEPRECATION errors.
TrustedCallbackInterface::TRIGGER_WARNING		constant	Untrusted callbacks trigger E_USER_WARNING errors.
UrlGeneratorTrait::$urlGenerator	protected	property	The url generator.
UrlGeneratorTrait::getUrlGenerator Deprecated	protected	function	Returns the URL generator service.
UrlGeneratorTrait::redirect Deprecated	protected	function	Returns a redirect response object for the specified route.	3
UrlGeneratorTrait::setUrlGenerator Deprecated	public	function	Sets the URL generator service.
UrlGeneratorTrait::url Deprecated	protected	function	Generates a URL or path for a specific route based on the given parameters.