You are here

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

class Page in Zircon Profile 8

Same name in this branch
  1. 8 core/lib/Drupal/Core/Render/Element/Page.php \Drupal\Core\Render\Element\Page
  2. 8 core/modules/views/src/Plugin/views/display/Page.php \Drupal\views\Plugin\views\display\Page
Same name and namespace in other branches
  1. 8.0 core/modules/views/src/Plugin/views/display/Page.php \Drupal\views\Plugin\views\display\Page

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

Expanded class hierarchy of 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
Contains \Drupal\Tests\views\Unit\Plugin\display\PageTest.
ViewExecutableTest.php in core/modules/views/src/Tests/ViewExecutableTest.php
Contains \Drupal\views\Tests\ViewExecutableTest.
ViewPageController.php in core/modules/views/src/Routing/ViewPageController.php
Contains \Drupal\views\Routing\ViewPageController.
ViewStorageTest.php in core/modules/views/src/Tests/ViewStorageTest.php
Contains \Drupal\views\Tests\ViewStorageTest.
99 string references to 'Page'
ConditionFormTest::testConfigForm in core/modules/system/src/Tests/Condition/ConditionFormTest.php
Submit the condition_node_type_test_form to test condition forms.
ContentTranslationEntityBundleUITest::testContentTypeUI in core/modules/content_translation/src/Tests/ContentTranslationEntityBundleUITest.php
Tests content types default translation behaviour.
ContextPluginTest::testContext in core/modules/system/src/Tests/Plugin/ContextPluginTest.php
Tests basic context definition and value getters and setters.
DisplayAttachmentTest::testAttachmentUI in core/modules/views_ui/src/Tests/DisplayAttachmentTest.php
Tests the attachment UI.
DisplayCRUDTest::testDuplicateDisplay in core/modules/views_ui/src/Tests/DisplayCRUDTest.php
Tests the duplicating of a display.

... See full list

File

core/modules/views/src/Plugin/views/display/Page.php, line 34
Contains \Drupal\views\Plugin\views\display\Page.

Namespace

Drupal\views\Plugin\views\display
View source 
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.manager')
      ->getStorage('menu'));
  }

  /**
   * 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'] = array(
      'contains' => array(
        'type' => array(
          'default' => 'none',
        ),
        'title' => array(
          'default' => '',
        ),
        'description' => array(
          'default' => '',
        ),
        'weight' => array(
          'default' => 0,
        ),
        'menu_name' => array(
          'default' => 'main',
        ),
        'parent' => array(
          'default' => '',
        ),
        'context' => array(
          'default' => '',
        ),
        'expanded' => array(
          'default' => FALSE,
        ),
      ),
    );
    $options['tab_options'] = array(
      'contains' => array(
        'type' => array(
          'default' => 'none',
        ),
        'title' => array(
          'default' => '',
        ),
        'description' => array(
          'default' => '',
        ),
        'weight' => array(
          '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 += array(
        '#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 = array(
        'type' => 'none',
      );
    }
    switch ($menu['type']) {
      case 'none':
      default:
        $menu_str = $this
          ->t('No menu');
        break;
      case 'normal':
        $menu_str = $this
          ->t('Normal: @title', array(
          '@title' => $menu['title'],
        ));
        break;
      case 'tab':
      case 'default tab':
        $menu_str = $this
          ->t('Tab: @title', array(
          '@title' => $menu['title'],
        ));
        break;
    }
    $options['menu'] = array(
      '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'] = array(
          '#prefix' => '<div class="clearfix">',
          '#suffix' => '</div>',
          '#tree' => TRUE,
        );
        $menu = $this
          ->getOption('menu');
        if (empty($menu)) {
          $menu = array(
            'type' => 'none',
            'title' => '',
            'weight' => 0,
            'expanded' => FALSE,
          );
        }
        $form['menu']['type'] = array(
          '#prefix' => '<div class="views-left-30">',
          '#suffix' => '</div>',
          '#title' => $this
            ->t('Type'),
          '#type' => 'radios',
          '#options' => array(
            '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'] = array(
          '#prefix' => '<div class="views-left-50">',
          '#title' => $this
            ->t('Menu link title'),
          '#type' => 'textfield',
          '#default_value' => $menu['title'],
          '#states' => array(
            'visible' => array(
              array(
                ':input[name="menu[type]"]' => array(
                  'value' => 'normal',
                ),
              ),
              array(
                ':input[name="menu[type]"]' => array(
                  'value' => 'tab',
                ),
              ),
              array(
                ':input[name="menu[type]"]' => array(
                  'value' => 'default tab',
                ),
              ),
            ),
          ),
        );
        $form['menu']['description'] = array(
          '#title' => $this
            ->t('Description'),
          '#type' => 'textfield',
          '#default_value' => $menu['description'],
          '#description' => $this
            ->t("Shown when hovering over the menu link."),
          '#states' => array(
            'visible' => array(
              array(
                ':input[name="menu[type]"]' => array(
                  'value' => 'normal',
                ),
              ),
              array(
                ':input[name="menu[type]"]' => array(
                  'value' => 'tab',
                ),
              ),
              array(
                ':input[name="menu[type]"]' => array(
                  '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'] += array(
            '#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' => array(
              'class' => array(
                'menu-title-select',
              ),
            ),
            '#states' => array(
              'visible' => array(
                array(
                  ':input[name="menu[type]"]' => array(
                    'value' => 'normal',
                  ),
                ),
                array(
                  ':input[name="menu[type]"]' => array(
                    'value' => 'tab',
                  ),
                ),
              ),
            ),
          );
        }
        else {
          $form['menu']['parent'] = array(
            '#type' => 'value',
            '#value' => $menu_parent,
          );
          $form['menu']['markup'] = array(
            '#markup' => $this
              ->t('Menu selection requires the activation of Menu UI module.'),
          );
        }
        $form['menu']['weight'] = array(
          '#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' => array(
            'visible' => array(
              array(
                ':input[name="menu[type]"]' => array(
                  'value' => 'normal',
                ),
              ),
              array(
                ':input[name="menu[type]"]' => array(
                  'value' => 'tab',
                ),
              ),
              array(
                ':input[name="menu[type]"]' => array(
                  'value' => 'default tab',
                ),
              ),
            ),
          ),
        );
        $form['menu']['context'] = array(
          '#title' => $this
            ->t('Context'),
          '#suffix' => '</div>',
          '#type' => 'checkbox',
          '#default_value' => !empty($menu['context']),
          '#description' => $this
            ->t('Displays the link in contextual links'),
          '#states' => array(
            'visible' => array(
              ':input[name="menu[type]"]' => array(
                '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 = array(
            'type' => 'none',
            'title' => '',
            'weight' => 0,
          );
        }
        $form['tab_markup'] = array(
          '#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'] = array(
          '#prefix' => '<div class="clearfix">',
          '#suffix' => '</div>',
          '#tree' => TRUE,
        );
        $form['tab_options']['type'] = array(
          '#prefix' => '<div class="views-left-25">',
          '#suffix' => '</div>',
          '#title' => $this
            ->t('Parent menu item'),
          '#type' => 'radios',
          '#options' => array(
            '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'] = array(
          '#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' => array(
            'visible' => array(
              array(
                ':input[name="tab_options[type]"]' => array(
                  'value' => 'normal',
                ),
              ),
              array(
                ':input[name="tab_options[type]"]' => array(
                  'value' => 'tab',
                ),
              ),
            ),
          ),
        );
        $form['tab_options']['description'] = array(
          '#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' => array(
            'visible' => array(
              array(
                ':input[name="tab_options[type]"]' => array(
                  'value' => 'normal',
                ),
              ),
              array(
                ':input[name="tab_options[type]"]' => array(
                  'value' => 'tab',
                ),
              ),
            ),
          ),
        );
        $form['tab_options']['weight'] = array(
          '#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' => array(
            'visible' => array(
              ':input[name="tab_options[type]"]' => array(
                '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(array(
        '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(array(
        '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(array(
          '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.', array(
        '@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.', array(
          '@display' => $this->display['display_title'],
        ));
      }
    }
    return $errors;
  }

  /**
   * {@inheritdoc}
   */
  public function getArgumentText() {
    return array(
      '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 array(
      'items per page title' => $this
        ->t('Items per page'),
      'items per page description' => $this
        ->t('The number of items to display per page. 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

Namesort descending Modifiers Type Description Overrides
DependencySerializationTrait::$_serviceIds protected property An array of service IDs keyed by property name used for serialization.
DependencySerializationTrait::__sleep public function 1
DependencySerializationTrait::__wakeup public function 2
DependencyTrait::$dependencies protected property The object's dependencies. 1
DependencyTrait::addDependencies protected function Adds multiple dependencies.
DependencyTrait::addDependency protected function Adds a dependency.
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 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 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
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::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 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::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 5
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
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::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::getRoute protected function Generates a route entry for a given view and display.
PathPluginBase::getRouteName public function Returns the route name for the display. Overrides DisplayRouterInterface::getRouteName
PathPluginBase::getUrlInfo public function Generates an 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::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. 2
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.
PluginBase::$pluginId protected property The plugin_id.
PluginBase::$renderer protected property Stores the render API renderer. 2
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
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::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
StringTranslationTrait::$stringTranslation protected property The string translation service.
StringTranslationTrait::formatPlural protected function Formats a string containing a count of items.
StringTranslationTrait::getNumberOfPlurals protected function Returns the number of plurals supported by a given language.
StringTranslationTrait::getStringTranslation protected function Gets the string translation service.
StringTranslationTrait::setStringTranslation public function Sets the string translation service to use. 2
StringTranslationTrait::t protected function Translates a string to the current language or to a given language.
UrlGeneratorTrait::$urlGenerator protected property The url generator.
UrlGeneratorTrait::getUrlGenerator protected function Returns the URL generator service.
UrlGeneratorTrait::redirect protected function Returns a redirect response object for the specified route.
UrlGeneratorTrait::setUrlGenerator public function Sets the URL generator service.
UrlGeneratorTrait::url protected function Generates a URL or path for a specific route based on the given parameters.