abstract class PluginBase in Drupal 9
Same name in this branch
- 9 core/lib/Drupal/Core/Plugin/PluginBase.php \Drupal\Core\Plugin\PluginBase
- 9 core/lib/Drupal/Component/Plugin/PluginBase.php \Drupal\Component\Plugin\PluginBase
- 9 core/modules/views/src/Plugin/views/PluginBase.php \Drupal\views\Plugin\views\PluginBase
Same name and namespace in other branches
- 8 core/modules/views/src/Plugin/views/PluginBase.php \Drupal\views\Plugin\views\PluginBase
Base class for any views plugin types.
Via the @Plugin definition the plugin may specify a theme function or template to be used for the plugin. It also can auto-register the theme implementation for that file or function.
- theme: the theme implementation to use in the plugin. This may be the name of the function (without theme_ prefix) or the template file (without template engine extension). If a template file should be used, the file has to be placed in the module's templates folder. Example: theme = "mymodule_row" of module "mymodule" will implement mymodule-row.html.twig in the [..]/modules/mymodule/templates folder.
- register_theme: (optional) When set to TRUE (default) the theme is registered automatically. When set to FALSE the plugin reuses an existing theme implementation, defined by another module or views plugin.
- theme_file: (optional) the location of an include file that may hold the theme or preprocess function. The location has to be relative to module's root directory.
- module: machine name of the module. It must be present for any plugin that wants to register a theme.
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\Core\Plugin\PluginBase uses DependencySerializationTrait, MessengerTrait, StringTranslationTrait
Expanded class hierarchy of PluginBase
Related topics
20 files declare their use of PluginBase
- AccessPluginBase.php in core/
modules/ views/ src/ Plugin/ views/ access/ AccessPluginBase.php - ArgumentDefaultPluginBase.php in core/
modules/ views/ src/ Plugin/ views/ argument_default/ ArgumentDefaultPluginBase.php - ArgumentValidatorPluginBase.php in core/
modules/ views/ src/ Plugin/ views/ argument_validator/ ArgumentValidatorPluginBase.php - CachePluginBase.php in core/
modules/ views/ src/ Plugin/ views/ cache/ CachePluginBase.php - DisplayExtenderPluginBase.php in core/
modules/ views/ src/ Plugin/ views/ display_extender/ DisplayExtenderPluginBase.php
File
- core/
modules/ views/ src/ Plugin/ views/ PluginBase.php, line 42
Namespace
Drupal\views\Plugin\viewsView source
abstract class PluginBase extends ComponentPluginBase implements ContainerFactoryPluginInterface, ViewsPluginInterface, DependentPluginInterface, TrustedCallbackInterface {
/**
* Include negotiated languages when listing languages.
*
* @see \Drupal\views\Plugin\views\PluginBase::listLanguages()
*/
const INCLUDE_NEGOTIATED = 16;
/**
* Include entity row languages when listing languages.
*
* @see \Drupal\views\Plugin\views\PluginBase::listLanguages()
*/
const INCLUDE_ENTITY = 32;
/**
* Query string to indicate the site default language.
*
* @see \Drupal\Core\Language\LanguageInterface::LANGCODE_DEFAULT
*/
const VIEWS_QUERY_LANGUAGE_SITE_DEFAULT = '***LANGUAGE_site_default***';
/**
* Options for this plugin will be held here.
*
* @var array
*/
public $options = [];
/**
* The top object of a view.
*
* @var \Drupal\views\ViewExecutable
*/
public $view = NULL;
/**
* The display object this plugin is for.
*
* For display plugins this is empty.
*
* @todo find a better description
*
* @var \Drupal\views\Plugin\views\display\DisplayPluginBase
*/
public $displayHandler;
/**
* Plugins's definition.
*
* @var array
*/
public $definition;
/**
* Denotes whether the plugin has an additional options form.
*
* @var bool
*/
protected $usesOptions = FALSE;
/**
* Stores the render API renderer.
*
* @var \Drupal\Core\Render\RendererInterface
*/
protected $renderer;
/**
* Constructs a PluginBase 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.
*/
public function __construct(array $configuration, $plugin_id, $plugin_definition) {
parent::__construct($configuration, $plugin_id, $plugin_definition);
$this->definition = $plugin_definition + $configuration;
}
/**
* {@inheritdoc}
*/
public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
return new static($configuration, $plugin_id, $plugin_definition);
}
/**
* {@inheritdoc}
*/
public function init(ViewExecutable $view, DisplayPluginBase $display, array &$options = NULL) {
$this->view = $view;
$this
->setOptionDefaults($this->options, $this
->defineOptions());
$this->displayHandler = $display;
$this
->unpackOptions($this->options, $options);
}
/**
* Information about options for all kinds of purposes will be held here.
* @code
* 'option_name' => array(
* - 'default' => default value,
* - 'contains' => (optional) array of items this contains, with its own
* defaults, etc. If contains is set, the default will be ignored and
* assumed to be array().
* ),
* @endcode
*
* @return array
* Returns the options of this handler/plugin.
*/
protected function defineOptions() {
return [];
}
/**
* Fills up the options of the plugin with defaults.
*
* @param array $storage
* An array which stores the actual option values of the plugin.
* @param array $options
* An array which describes the options of a plugin. Each element is an
* associative array containing:
* - default: The default value of one option. Should be translated to the
* interface text language selected for page if translatable.
* - (optional) contains: An array which describes the available options
* under the key. If contains is set, the default will be ignored and
* assumed to be an empty array.
* - (optional) 'bool': TRUE if the value is boolean, else FALSE.
*/
protected function setOptionDefaults(array &$storage, array $options) {
foreach ($options as $option => $definition) {
if (isset($definition['contains'])) {
$storage[$option] = [];
$this
->setOptionDefaults($storage[$option], $definition['contains']);
}
else {
$storage[$option] = $definition['default'];
}
}
}
/**
* {@inheritdoc}
*/
public function filterByDefinedOptions(array &$storage) {
$this
->doFilterByDefinedOptions($storage, $this
->defineOptions());
}
/**
* Do the work to filter out stored options depending on the defined options.
*
* @param array $storage
* The stored options.
* @param array $options
* The defined options.
*/
protected function doFilterByDefinedOptions(array &$storage, array $options) {
foreach ($storage as $key => $sub_storage) {
if (!isset($options[$key])) {
unset($storage[$key]);
}
if (isset($options[$key]['contains'])) {
$this
->doFilterByDefinedOptions($storage[$key], $options[$key]['contains']);
}
}
}
/**
* {@inheritdoc}
*/
public function unpackOptions(&$storage, $options, $definition = NULL, $all = TRUE, $check = TRUE) {
if ($check && !is_array($options)) {
return;
}
if (!isset($definition)) {
$definition = $this
->defineOptions();
}
foreach ($options as $key => $value) {
if (is_array($value)) {
// Ignore arrays with no definition.
if (!$all && empty($definition[$key])) {
continue;
}
if (!isset($storage[$key]) || !is_array($storage[$key])) {
$storage[$key] = [];
}
// If we're just unpacking our known options, and we're dropping an
// unknown array (as might happen for a dependent plugin fields) go
// ahead and drop that in.
if (!$all && isset($definition[$key]) && !isset($definition[$key]['contains'])) {
$storage[$key] = $value;
continue;
}
$this
->unpackOptions($storage[$key], $value, isset($definition[$key]['contains']) ? $definition[$key]['contains'] : [], $all, FALSE);
}
elseif ($all || !empty($definition[$key])) {
$storage[$key] = $value;
}
}
}
/**
* {@inheritdoc}
*/
public function destroy() {
unset($this->view, $this->display, $this->query);
}
/**
* {@inheritdoc}
*/
public function buildOptionsForm(&$form, FormStateInterface $form_state) {
// Some form elements belong in a fieldset for presentation, but can't
// be moved into one because of the $form_state->getValues() hierarchy. Those
// elements can add a #fieldset => 'fieldset_name' property, and they'll
// be moved to their fieldset during pre_render.
$form['#pre_render'][] = [
static::class,
'preRenderAddFieldsetMarkup',
];
}
/**
* {@inheritdoc}
*/
public static function trustedCallbacks() {
return [
'preRenderAddFieldsetMarkup',
];
}
/**
* {@inheritdoc}
*/
public function validateOptionsForm(&$form, FormStateInterface $form_state) {
}
/**
* {@inheritdoc}
*/
public function submitOptionsForm(&$form, FormStateInterface $form_state) {
}
/**
* {@inheritdoc}
*/
public function query() {
}
/**
* {@inheritdoc}
*/
public function themeFunctions() {
return $this->view
->buildThemeFunctions($this->definition['theme']);
}
/**
* {@inheritdoc}
*/
public function validate() {
return [];
}
/**
* {@inheritdoc}
*/
public function summaryTitle() {
return $this
->t('Settings');
}
/**
* {@inheritdoc}
*/
public function pluginTitle() {
// Short_title is optional so its defaults to an empty string.
if (!empty($this->definition['short_title'])) {
return $this->definition['short_title'];
}
return $this->definition['title'];
}
/**
* {@inheritdoc}
*/
public function usesOptions() {
return $this->usesOptions;
}
/**
* {@inheritdoc}
*/
public function globalTokenReplace($string = '', array $options = []) {
return \Drupal::token()
->replace($string, [
'view' => $this->view,
], $options);
}
/**
* Replaces Views' tokens in a given string. The resulting string will be
* sanitized with Xss::filterAdmin.
*
* @param $text
* Unsanitized string with possible tokens.
* @param $tokens
* Array of token => replacement_value items.
*
* @return string
*/
protected function viewsTokenReplace($text, $tokens) {
if (!strlen($text)) {
// No need to run filterAdmin on an empty string.
return '';
}
if (empty($tokens)) {
return Xss::filterAdmin($text);
}
$twig_tokens = [];
foreach ($tokens as $token => $replacement) {
// Twig wants a token replacement array stripped of curly-brackets.
// Some Views tokens come with curly-braces, others do not.
// @todo: https://www.drupal.org/node/2544392
if (strpos($token, '{{') !== FALSE) {
// Twig wants a token replacement array stripped of curly-brackets.
$token = trim(str_replace([
'{{',
'}}',
], '', $token));
}
// Check for arrays in Twig tokens. Internally these are passed as
// dot-delimited strings, but need to be turned into associative arrays
// for parsing.
if (strpos($token, '.') === FALSE) {
// We need to validate tokens are valid Twig variables. Twig uses the
// same variable naming rules as PHP.
// @see http://php.net/manual/language.variables.basics.php
assert(preg_match('/^[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*$/', $token) === 1, 'Tokens need to be valid Twig variables.');
$twig_tokens[$token] = $replacement;
}
else {
$parts = explode('.', $token);
$top = array_shift($parts);
assert(preg_match('/^[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*$/', $top) === 1, 'Tokens need to be valid Twig variables.');
$token_array = [
array_pop($parts) => $replacement,
];
foreach (array_reverse($parts) as $key) {
// The key could also be numeric (array index) so allow that.
assert(is_numeric($key) || preg_match('/^[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*$/', $key) === 1, 'Tokens need to be valid Twig variables.');
$token_array = [
$key => $token_array,
];
}
if (!isset($twig_tokens[$top])) {
$twig_tokens[$top] = [];
}
$twig_tokens[$top] += $token_array;
}
}
if ($twig_tokens) {
// Use the unfiltered text for the Twig template, then filter the output.
// Otherwise, Xss::filterAdmin could remove valid Twig syntax before the
// template is parsed.
$build = [
'#type' => 'inline_template',
'#template' => $text,
'#context' => $twig_tokens,
'#post_render' => [
function ($children, $elements) {
return Xss::filterAdmin($children);
},
],
];
// Currently you cannot attach assets to tokens with
// Renderer::renderPlain(). This may be unnecessarily limiting. Consider
// using Renderer::executeInRenderContext() instead.
// @todo: https://www.drupal.org/node/2566621
return (string) $this
->getRenderer()
->renderPlain($build);
}
else {
return Xss::filterAdmin($text);
}
}
/**
* {@inheritdoc}
*/
public function getAvailableGlobalTokens($prepared = FALSE, array $types = []) {
$info = \Drupal::token()
->getInfo();
// Site and view tokens should always be available.
$types += [
'site',
'view',
];
$available = array_intersect_key($info['tokens'], array_flip($types));
// Construct the token string for each token.
if ($prepared) {
$prepared = [];
foreach ($available as $type => $tokens) {
foreach (array_keys($tokens) as $token) {
$prepared[$type][] = "[{$type}:{$token}]";
}
}
return $prepared;
}
return $available;
}
/**
* {@inheritdoc}
*/
public function globalTokenForm(&$form, FormStateInterface $form_state) {
$token_items = [];
foreach ($this
->getAvailableGlobalTokens() as $type => $tokens) {
$item = [
'#markup' => $type,
'children' => [],
];
foreach ($tokens as $name => $info) {
$item['children'][$name] = "[{$type}:{$name}]" . ' - ' . $info['name'] . ': ' . $info['description'];
}
$token_items[$type] = $item;
}
$form['global_tokens'] = [
'#type' => 'details',
'#title' => $this
->t('Available global token replacements'),
];
$form['global_tokens']['list'] = [
'#theme' => 'item_list',
'#items' => $token_items,
'#attributes' => [
'class' => [
'global-tokens',
],
],
];
}
/**
* {@inheritdoc}
*/
public static function preRenderAddFieldsetMarkup(array $form) {
foreach (Element::children($form) as $key) {
$element = $form[$key];
// In our form builder functions, we added an arbitrary #fieldset property
// to any element that belongs in a fieldset. If this form element has
// that property, move it into its fieldset.
if (isset($element['#fieldset']) && isset($form[$element['#fieldset']])) {
$form[$element['#fieldset']][$key] = $element;
// Remove the original element this duplicates.
unset($form[$key]);
}
}
return $form;
}
/**
* {@inheritdoc}
*/
public static function preRenderFlattenData($form) {
foreach (Element::children($form) as $key) {
$element = $form[$key];
if (!empty($element['#flatten'])) {
foreach (Element::children($element) as $child_key) {
$form[$child_key] = $form[$key][$child_key];
}
// All done, remove the now-empty parent.
unset($form[$key]);
}
}
return $form;
}
/**
* {@inheritdoc}
*/
public function calculateDependencies() {
return [];
}
/**
* {@inheritdoc}
*/
public function getProvider() {
$definition = $this
->getPluginDefinition();
return $definition['provider'];
}
/**
* Makes an array of languages, optionally including special languages.
*
* @param int $flags
* (optional) Flags for which languages to return (additive). Options:
* - \Drupal\Core\Language::STATE_ALL (default): All languages
* (configurable and default).
* - \Drupal\Core\Language::STATE_CONFIGURABLE: Configurable languages.
* - \Drupal\Core\Language::STATE_LOCKED: Locked languages.
* - \Drupal\Core\Language::STATE_SITE_DEFAULT: Add site default language;
* note that this is not included in STATE_ALL.
* - \Drupal\views\Plugin\views\PluginBase::INCLUDE_NEGOTIATED: Add
* negotiated language types.
* - \Drupal\views\Plugin\views\PluginBase::INCLUDE_ENTITY: Add
* entity row language types. Note that these are only supported for
* display options, not substituted in queries.
* @param array|null $current_values
* The currently-selected options in the list, if available.
*
* @return array
* An array of language names, keyed by the language code. Negotiated and
* special languages have special codes that are substituted in queries by
* PluginBase::queryLanguageSubstitutions().
* Only configurable languages and languages that are in $current_values are
* included in the list.
*/
protected function listLanguages($flags = LanguageInterface::STATE_ALL, array $current_values = NULL) {
$manager = \Drupal::languageManager();
$languages = $manager
->getLanguages($flags);
$list = [];
// The entity languages should come first, if requested.
if ($flags & PluginBase::INCLUDE_ENTITY) {
$list['***LANGUAGE_entity_translation***'] = $this
->t('Content language of view row');
$list['***LANGUAGE_entity_default***'] = $this
->t('Original language of content in view row');
}
// STATE_SITE_DEFAULT comes in with ID set
// to LanguageInterface::LANGCODE_SITE_DEFAULT.
// Since this is not a real language, surround it by '***LANGUAGE_...***',
// like the negotiated languages below.
if ($flags & LanguageInterface::STATE_SITE_DEFAULT) {
$name = $languages[LanguageInterface::LANGCODE_SITE_DEFAULT]
->getName();
// The language name may have already been translated, no need to
// translate it again.
// @see Drupal\Core\Language::filterLanguages().
if (!$name instanceof TranslatableMarkup) {
$name = $this
->t($name);
}
$list[PluginBase::VIEWS_QUERY_LANGUAGE_SITE_DEFAULT] = $name;
// Remove site default language from $languages so it's not added
// twice with the real languages below.
unset($languages[LanguageInterface::LANGCODE_SITE_DEFAULT]);
}
// Add in negotiated languages, if requested.
if ($flags & PluginBase::INCLUDE_NEGOTIATED) {
$types_info = $manager
->getDefinedLanguageTypesInfo();
$types = $manager
->getLanguageTypes();
// We only go through the configured types.
foreach ($types as $id) {
if (isset($types_info[$id]['name'])) {
$name = $types_info[$id]['name'];
// Surround IDs by '***LANGUAGE_...***', to avoid query collisions.
$id = '***LANGUAGE_' . $id . '***';
$list[$id] = $this
->t('@type language selected for page', [
'@type' => $name,
]);
}
}
if (!empty($current_values)) {
foreach ($types_info as $id => $type) {
$id = '***LANGUAGE_' . $id . '***';
// If this (non-configurable) type is among the current values,
// add that option too, so it is not lost. If not among the current
// values, skip displaying it to avoid user confusion.
if (isset($type['name']) && !isset($list[$id]) && in_array($id, $current_values, TRUE)) {
$list[$id] = $this
->t('@type language selected for page', [
'@type' => $type['name'],
]);
}
}
}
}
// Add real languages.
foreach ($languages as $id => $language) {
$list[$id] = $language
->getName();
}
return $list;
}
/**
* Returns substitutions for Views queries for languages.
*
* This is needed so that the language options returned by
* PluginBase::listLanguages() are able to be used in queries. It is called
* by the Views module implementation of hook_views_query_substitutions()
* to get the language-related substitutions.
*
* @return array
* An array in the format of hook_views_query_substitutions() that gives
* the query substitutions needed for the special language types.
*/
public static function queryLanguageSubstitutions() {
$changes = [];
$manager = \Drupal::languageManager();
// Handle default language.
$default = $manager
->getDefaultLanguage()
->getId();
$changes[PluginBase::VIEWS_QUERY_LANGUAGE_SITE_DEFAULT] = $default;
// Handle negotiated languages.
$types = $manager
->getDefinedLanguageTypesInfo();
foreach ($types as $id => $type) {
if (isset($type['name'])) {
$changes['***LANGUAGE_' . $id . '***'] = $manager
->getCurrentLanguage($id)
->getId();
}
}
return $changes;
}
/**
* Returns the render API renderer.
*
* @return \Drupal\Core\Render\RendererInterface
*/
protected function getRenderer() {
if (!isset($this->renderer)) {
$this->renderer = \Drupal::service('renderer');
}
return $this->renderer;
}
}
Members
Name | Modifiers | Type | Description | Overrides |
---|---|---|---|---|
DependencySerializationTrait:: |
protected | property | ||
DependencySerializationTrait:: |
protected | property | ||
DependencySerializationTrait:: |
public | function | 2 | |
DependencySerializationTrait:: |
public | function | 2 | |
MessengerTrait:: |
protected | property | The messenger. | 27 |
MessengerTrait:: |
public | function | Gets the messenger. | 27 |
MessengerTrait:: |
public | function | Sets the messenger. | |
PluginBase:: |
protected | property | Configuration information passed into the plugin. | 1 |
PluginBase:: |
public | property | Plugins's definition. | |
PluginBase:: |
public | property | The display object this plugin is for. | |
PluginBase:: |
public | property | Options for this plugin will be held here. | |
PluginBase:: |
protected | property | The plugin implementation definition. | 1 |
PluginBase:: |
protected | property | The plugin_id. | |
PluginBase:: |
protected | property | Stores the render API renderer. | 3 |
PluginBase:: |
protected | property | Denotes whether the plugin has an additional options form. | 8 |
PluginBase:: |
public | property | The top object of a view. | 1 |
PluginBase:: |
public | function |
Provide a form to edit options for this plugin. Overrides ViewsPluginInterface:: |
16 |
PluginBase:: |
public | function |
Calculates dependencies for the configured plugin. Overrides DependentPluginInterface:: |
14 |
PluginBase:: |
public static | function |
Creates an instance of the plugin. Overrides ContainerFactoryPluginInterface:: |
63 |
PluginBase:: |
protected | function | Information about options for all kinds of purposes will be held here. | 18 |
PluginBase:: |
constant | A string which is used to separate base plugin IDs from the derivative ID. | ||
PluginBase:: |
public | function |
Clears a plugin. Overrides ViewsPluginInterface:: |
2 |
PluginBase:: |
protected | function | Do the work to filter out stored options depending on the defined options. | |
PluginBase:: |
public | function |
Filter out stored options depending on the defined options. Overrides ViewsPluginInterface:: |
|
PluginBase:: |
public | function |
Returns an array of available token replacements. Overrides ViewsPluginInterface:: |
|
PluginBase:: |
public | function |
Gets the base_plugin_id of the plugin instance. Overrides DerivativeInspectionInterface:: |
|
PluginBase:: |
public | function |
Gets the derivative_id of the plugin instance. Overrides DerivativeInspectionInterface:: |
|
PluginBase:: |
public | function |
Gets the definition of the plugin implementation. Overrides PluginInspectionInterface:: |
2 |
PluginBase:: |
public | function |
Gets the plugin_id of the plugin instance. Overrides PluginInspectionInterface:: |
|
PluginBase:: |
public | function |
Returns the plugin provider. Overrides ViewsPluginInterface:: |
|
PluginBase:: |
protected | function | Returns the render API renderer. | 1 |
PluginBase:: |
public | function |
Adds elements for available core tokens to a form. Overrides ViewsPluginInterface:: |
|
PluginBase:: |
public | function |
Returns a string with any core tokens replaced. Overrides ViewsPluginInterface:: |
|
PluginBase:: |
constant | Include entity row languages when listing languages. | ||
PluginBase:: |
constant | Include negotiated languages when listing languages. | ||
PluginBase:: |
public | function |
Initialize the plugin. Overrides ViewsPluginInterface:: |
6 |
PluginBase:: |
public | function | Determines if the plugin is configurable. | |
PluginBase:: |
protected | function | Makes an array of languages, optionally including special languages. | |
PluginBase:: |
public | function |
Return the human readable name of the display. Overrides ViewsPluginInterface:: |
|
PluginBase:: |
public static | function |
Moves form elements into fieldsets for presentation purposes. Overrides ViewsPluginInterface:: |
|
PluginBase:: |
public static | function |
Flattens the structure of form elements. Overrides ViewsPluginInterface:: |
|
PluginBase:: |
public | function |
Add anything to the query that we might need to. Overrides ViewsPluginInterface:: |
8 |
PluginBase:: |
public static | function | Returns substitutions for Views queries for languages. | |
PluginBase:: |
protected | function | Fills up the options of the plugin with defaults. | |
PluginBase:: |
public | function |
Handle any special handling on the validate form. Overrides ViewsPluginInterface:: |
16 |
PluginBase:: |
public | function |
Returns the summary of the settings in the display. Overrides ViewsPluginInterface:: |
6 |
PluginBase:: |
public | function |
Provide a full list of possible theme templates used by this style. Overrides ViewsPluginInterface:: |
1 |
PluginBase:: |
public static | function |
Lists the trusted callbacks provided by the implementing class. Overrides TrustedCallbackInterface:: |
6 |
PluginBase:: |
public | function |
Unpack options over our existing defaults, drilling down into arrays
so that defaults don't get totally blown away. Overrides ViewsPluginInterface:: |
|
PluginBase:: |
public | function |
Returns the usesOptions property. Overrides ViewsPluginInterface:: |
8 |
PluginBase:: |
public | function |
Validate that the plugin is correct and can be saved. Overrides ViewsPluginInterface:: |
6 |
PluginBase:: |
public | function |
Validate the options form. Overrides ViewsPluginInterface:: |
15 |
PluginBase:: |
protected | function | Replaces Views' tokens in a given string. The resulting string will be sanitized with Xss::filterAdmin. | 1 |
PluginBase:: |
constant | Query string to indicate the site default language. | ||
PluginBase:: |
public | function |
Constructs a PluginBase object. Overrides PluginBase:: |
|
StringTranslationTrait:: |
protected | property | The string translation service. | 4 |
StringTranslationTrait:: |
protected | function | Formats a string containing a count of items. | |
StringTranslationTrait:: |
protected | function | Returns the number of plurals supported by a given language. | |
StringTranslationTrait:: |
protected | function | Gets the string translation service. | |
StringTranslationTrait:: |
public | function | Sets the string translation service to use. | 2 |
StringTranslationTrait:: |
protected | function | Translates a string to the current language or to a given language. | |
TrustedCallbackInterface:: |
constant | Untrusted callbacks throw exceptions. | ||
TrustedCallbackInterface:: |
constant | Untrusted callbacks trigger silenced E_USER_DEPRECATION errors. | ||
TrustedCallbackInterface:: |
constant | Untrusted callbacks trigger E_USER_WARNING errors. |