/** * {@inheritdoc} */ public function query($group_by = FALSE) { $required = FALSE; $this->queryParseSearchExpression($this->argument); if (!isset($this->searchQuery)) { $required = TRUE; } else { $words = $this->searchQuery->words(); if (empty($words)) { $required = TRUE; } } if ($required) { if ($this->operator == 'required') { $this->query->addWhere(0, 'FALSE'); } } else { $search_index = $this->ensureMyTable(); $search_condition = db_and(); // Create a new join to relate the 'search_total' table to our current 'search_index' table. $definition = array('table' => 'search_total', 'field' => 'word', 'left_table' => $search_index, 'left_field' => 'word'); $join = Views::pluginManager('join')->createInstance('standard', $definition); $search_total = $this->query->addRelationship('search_total', $join, $search_index); // Add the search score field to the query. $this->search_score = $this->query->addField('', "{$search_index}.score * {$search_total}.count", 'score', array('function' => 'sum')); // Add the conditions set up by the search query to the views query. $search_condition->condition("{$search_index}.type", $this->searchType); $search_dataset = $this->query->addTable('node_search_dataset'); $conditions = $this->searchQuery->conditions(); $condition_conditions =& $conditions->conditions(); foreach ($condition_conditions as $key => &$condition) { // Make sure we just look at real conditions. if (is_numeric($key)) { // Replace the conditions with the table alias of views. $this->searchQuery->conditionReplaceString('d.', "{$search_dataset}.", $condition); } } $search_conditions =& $search_condition->conditions(); $search_conditions = array_merge($search_conditions, $condition_conditions); // Add the keyword conditions, as is done in // SearchQuery::prepareAndNormalize(), but simplified because we are // only concerned with relevance ranking so we do not need to normalize. $or = db_or(); foreach ($words as $word) { $or->condition("{$search_index}.word", $word); } $search_condition->condition($or); // Add the GROUP BY and HAVING expressions to the query. $this->query->addWhere(0, $search_condition); $this->query->addGroupBy("{$search_index}.sid"); $matches = $this->searchQuery->matches(); $placeholder = $this->placeholder(); $this->query->addHavingExpression(0, "COUNT(*) >= {$placeholder}", array($placeholder => $matches)); } // Set to NULL to prevent PDO exception when views object is cached // and to clear out memory. $this->searchQuery = NULL; }
/** * Tests views_ui_views_plugins_display_alter is altering plugin definitions. */ public function testDisplayPluginsAlter() { $definitions = Views::pluginManager('display')->getDefinitions(); $expected = array('route_name' => 'entity.view.edit_form', 'route_parameters_names' => array('view' => 'id')); // Test the expected views_ui array exists on each definition. foreach ($definitions as $definition) { $this->assertIdentical($definition['contextual links']['entity.view.edit_form'], $expected, 'Expected views_ui array found in plugin definition.'); } }
/** * {@inheritdoc} */ public function query($group_by = FALSE) { $required = FALSE; $this->queryParseSearchExpression($this->argument); if (!isset($this->searchQuery)) { $required = TRUE; } else { $words = $this->searchQuery->words(); if (empty($words)) { $required = TRUE; } } if ($required) { if ($this->operator == 'required') { $this->query->addWhere(0, 'FALSE'); } } else { $search_index = $this->ensureMyTable(); $search_condition = db_and(); // Create a new join to relate the 'search_total' table to our current 'search_index' table. $definition = array('table' => 'search_total', 'field' => 'word', 'left_table' => $search_index, 'left_field' => 'word'); $join = Views::pluginManager('join')->createInstance('standard', $definition); $search_total = $this->query->addRelationship('search_total', $join, $search_index); $this->search_score = $this->query->addField('', "SUM({$search_index}.score * {$search_total}.count)", 'score', array('aggregate' => TRUE)); $search_condition->condition("{$search_index}.type", $this->searchType); if (!$this->searchQuery->simple()) { $search_dataset = $this->query->addTable('search_dataset'); $conditions = $this->searchQuery->conditions(); $condition_conditions =& $conditions->conditions(); foreach ($condition_conditions as $key => &$condition) { // Make sure we just look at real conditions. if (is_numeric($key)) { // Replace the conditions with the table alias of views. $this->searchQuery->conditionReplaceString('d.', "{$search_dataset}.", $condition); } } $search_conditions =& $search_condition->conditions(); $search_conditions = array_merge($search_conditions, $condition_conditions); } else { // Stores each condition, so and/or on the filter level will still work. $or = db_or(); foreach ($words as $word) { $or->condition("{$search_index}.word", $word); } $search_condition->condition($or); } $this->query->addWhere(0, $search_condition); $this->query->addGroupBy("{$search_index}.sid"); $matches = $this->searchQuery->matches(); $placeholder = $this->placeholder(); $this->query->addHavingExpression(0, "COUNT(*) >= {$placeholder}", array($placeholder => $matches)); } // Set to NULL to prevent PDO exception when views object is cached // and to clear out memory. $this->searchQuery = NULL; }
public function query() { $this->ensureMyTable(); $max_depth = isset($this->definition['max depth']) ? $this->definition['max depth'] : MENU_MAX_DEPTH; for ($i = 1; $i <= $max_depth; ++$i) { if ($this->options['sort_within_level']) { $definition = array('table' => 'menu_links', 'field' => 'mlid', 'left_table' => $this->tableAlias, 'left_field' => $this->field . $i); $join = Views::pluginManager('join')->createInstance('standard', $definition); $menu_links = $this->query->addTable('menu_links', NULL, $join); $this->query->addOrderBy($menu_links, 'weight', $this->options['order']); $this->query->addOrderBy($menu_links, 'link_title', $this->options['order']); } // We need this even when also sorting by weight and title, to make sure // that children of two parents with the same weight and title are // correctly separated. $this->query->addOrderBy($this->tableAlias, $this->field . $i, $this->options['order']); } }
/** * {@inheritdoc} */ public function query() { $this->ensureMyTable(); // Therefore construct the join. // Add the join for the tmgmt_job_item table. $configuration = array('table' => 'tmgmt_job_item', 'field' => 'tjid', 'left_table' => $this->tableAlias, 'left_field' => 'tjid', 'operator' => '='); if (!empty($this->options['state'])) { $configuration['extra'] = [['field' => 'state', 'value' => $this->options['state']]]; } /** @var \Drupal\views\Plugin\views\join\Standard $join */ $join = Views::pluginManager('join')->createInstance('standard', $configuration); // Add the join to the tmgmt_job_item table. $this->tableAlias = $this->query->addTable('tmgmt_job_item', $this->relationship, $join); // And finally add the count of the job items field. $params = array('function' => 'count'); $this->field_alias = $this->query->addField($this->tableAlias, 'tjiid', NULL, $params); $this->addAdditionalFields(); }
/** * Renders this view for a certain display. * * Note: You should better use just the preview function if you want to * render a view. * * @param string $display_id * The machine name of the display, which should be rendered. * * @return array|null * A renderable array containing the view output or NULL if the build * process failed. */ public function render($display_id = NULL) { $this->execute($display_id); // Check to see if the build failed. if (!empty($this->build_info['fail'])) { return; } if (!empty($this->build_info['denied'])) { return; } $exposed_form = $this->display_handler->getPlugin('exposed_form'); $exposed_form->preRender($this->result); $module_handler = \Drupal::moduleHandler(); // @TODO In the longrun, it would be great to execute a view without // the theme system at all. See https://www.drupal.org/node/2322623. $active_theme = \Drupal::theme()->getActiveTheme(); $themes = array_keys($active_theme->getBaseThemes()); $themes[] = $active_theme->getName(); // Check for already-cached output. /** @var \Drupal\views\Plugin\views\cache\CachePluginBase $cache */ if (!empty($this->live_preview)) { $cache = Views::pluginManager('cache')->createInstance('none'); } else { $cache = $this->display_handler->getPlugin('cache'); } // Run preRender for the pager as it might change the result. if (!empty($this->pager)) { $this->pager->preRender($this->result); } // Initialize the style plugin. $this->initStyle(); if (!isset($this->response)) { // Set the response so other parts can alter it. $this->response = new Response('', 200); } // Give field handlers the opportunity to perform additional queries // using the entire resultset prior to rendering. if ($this->style_plugin->usesFields()) { foreach ($this->field as $id => $handler) { if (!empty($this->field[$id])) { $this->field[$id]->preRender($this->result); } } } $this->style_plugin->preRender($this->result); // Let each area handler have access to the result set. $areas = array('header', 'footer'); // Only call preRender() on the empty handlers if the result is empty. if (empty($this->result)) { $areas[] = 'empty'; } foreach ($areas as $area) { foreach ($this->{$area} as $handler) { $handler->preRender($this->result); } } // Let modules modify the view just prior to rendering it. $module_handler->invokeAll('views_pre_render', array($this)); // Let the themes play too, because pre render is a very themey thing. foreach ($themes as $theme_name) { $function = $theme_name . '_views_pre_render'; if (function_exists($function)) { $function($this); } } $this->display_handler->output = $this->display_handler->render(); $exposed_form->postRender($this->display_handler->output); $cache->postRender($this->display_handler->output); // Let modules modify the view output after it is rendered. $module_handler->invokeAll('views_post_render', array($this, &$this->display_handler->output, $cache)); // Let the themes play too, because post render is a very themey thing. foreach ($themes as $theme_name) { $function = $theme_name . '_views_post_render'; if (function_exists($function)) { $function($this, $this->display_handler->output, $cache); } } return $this->display_handler->output; }
/** * {@inheritdoc} */ public static function getTableJoin($table, $base_table) { $data = Views::viewsData()->get($table); if (isset($data['table']['join'][$base_table])) { $join_info = $data['table']['join'][$base_table]; if (!empty($join_info['join_id'])) { $id = $join_info['join_id']; } else { $id = 'standard'; } $configuration = $join_info; // Fill in some easy defaults. if (empty($configuration['table'])) { $configuration['table'] = $table; } // If this is empty, it's a direct link. if (empty($configuration['left_table'])) { $configuration['left_table'] = $base_table; } if (isset($join_info['arguments'])) { foreach ($join_info['arguments'] as $key => $argument) { $configuration[$key] = $argument; } } $join = Views::pluginManager('join')->createInstance($id, $configuration); return $join; } }
/** * Retrieves filter information based on user input for the default display. * * @param array $form * The full wizard form array. * @param \Drupal\Core\Form\FormStateInterface $form_state * The current state of the wizard form. * * @return array * An array of filter arrays keyed by ID. A sort array contains the options * accepted by a filter handler. */ protected function defaultDisplayFiltersUser(array $form, FormStateInterface $form_state) { $filters = array(); if (($type = $form_state->getValue(array('show', 'type'))) && $type != 'all') { $bundle_key = $this->entityType->getKey('bundle'); // Figure out the table where $bundle_key lives. It may not be the same as // the base table for the view; the taxonomy vocabulary machine_name, for // example, is stored in taxonomy_vocabulary, not taxonomy_term_data. module_load_include('inc', 'views_ui', 'admin'); $fields = Views::viewsDataHelper()->fetchFields($this->base_table, 'filter'); if (isset($fields[$this->base_table . '.' . $bundle_key])) { $table = $this->base_table; } else { foreach ($fields as $field_name => $value) { if ($pos = strpos($field_name, '.' . $bundle_key)) { $table = substr($field_name, 0, $pos); break; } } } $table_data = Views::viewsData()->get($table); // If the 'in' operator is being used, map the values to an array. $handler = $table_data[$bundle_key]['filter']['id']; $handler_definition = Views::pluginManager('filter')->getDefinition($handler); if ($handler == 'in_operator' || is_subclass_of($handler_definition['class'], 'Drupal\\views\\Plugin\\views\\filter\\InOperator')) { $value = array($type => $type); } else { $value = $type; } $filters[$bundle_key] = array('id' => $bundle_key, 'table' => $table, 'field' => $bundle_key, 'value' => $value); } return $filters; }
/** * {@inheritdoc} */ public function query() { // Figure out what base table this relationship brings to the party. $table_data = Views::viewsData()->get($this->definition['base']); $base_field = empty($this->definition['base field']) ? $table_data['table']['base']['field'] : $this->definition['base field']; $this->ensureMyTable(); $def = $this->definition; $def['table'] = $this->definition['base']; $def['field'] = $base_field; $def['left_table'] = $this->tableAlias; $def['left_field'] = $this->field; $def['adjusted'] = TRUE; if (!empty($this->options['required'])) { $def['type'] = 'INNER'; } if ($this->options['subquery_regenerate']) { // For testing only, regenerate the subquery each time. $def['left_query'] = $this->leftQuery($this->options); } else { // Get the stored subquery SQL string. $cid = 'views_relationship_groupwise_max:' . $this->view->storage->id() . ':' . $this->view->current_display . ':' . $this->options['id']; $cache = \Drupal::cache('data')->get($cid); if (isset($cache->data)) { $def['left_query'] = $cache->data; } else { $def['left_query'] = $this->leftQuery($this->options); \Drupal::cache('data')->set($cid, $def['left_query']); } } if (!empty($def['join_id'])) { $id = $def['join_id']; } else { $id = 'subquery'; } $join = Views::pluginManager('join')->createInstance($id, $def); // use a short alias for this: $alias = $def['table'] . '_' . $this->table; $this->alias = $this->query->addRelationship($alias, $join, $this->definition['base'], $this->relationship); }
/** * Perform any necessary changes to the form values prior to storage. * There is no need for this function to actually store the data. */ public function submitOptionsForm(&$form, &$form_state) { // Not sure I like this being here, but it seems (?) like a logical place. $cache_plugin = $this->getPlugin('cache'); if ($cache_plugin) { $cache_plugin->cacheFlush(); } $section = $form_state['section']; switch ($section) { case 'display_id': if (isset($form_state['values']['display_id'])) { $this->display['new_id'] = $form_state['values']['display_id']; } break; case 'display_title': $this->display['display_title'] = $form_state['values']['display_title']; $this->setOption('display_description', $form_state['values']['display_description']); break; case 'query': $plugin = $this->getPlugin('query'); if ($plugin) { $plugin->submitOptionsForm($form['query']['options'], $form_state); $this->setOption('query', $form_state['values'][$section]); } break; case 'link_display': $this->setOption('link_url', $form_state['values']['link_url']); case 'title': case 'css_class': case 'display_comment': case 'distinct': case 'group_by': $this->setOption($section, $form_state['values'][$section]); break; case 'field_langcode': $this->setOption('field_langcode', $form_state['values']['field_langcode']); $this->setOption('field_langcode_add_to_query', $form_state['values']['field_langcode_add_to_query']); break; case 'use_ajax': case 'hide_attachment_summary': case 'show_admin_links': case 'exposed_block': $this->setOption($section, (bool) $form_state['values'][$section]); break; case 'use_more': $this->setOption($section, intval($form_state['values'][$section])); $this->setOption('use_more_always', intval($form_state['values']['use_more_always'])); $this->setOption('use_more_text', $form_state['values']['use_more_text']); break; case 'access': case 'cache': case 'exposed_form': case 'pager': case 'row': case 'style': $plugin_type = $section; $plugin_options = $this->getOption($plugin_type); if ($plugin_options['type'] != $form_state['values'][$plugin_type]['type']) { $plugin = Views::pluginManager($plugin_type)->createInstance($form_state['values'][$plugin_type]['type']); if ($plugin) { $plugin->init($this->view, $this, $plugin_options['options']); $plugin_options = array('type' => $form_state['values'][$plugin_type]['type'], 'options' => $plugin->options, 'provider' => $plugin->definition['provider']); $this->setOption($plugin_type, $plugin_options); if ($plugin->usesOptions()) { $form_state['view']->addFormToStack('display', $this->display['id'], $plugin_type . '_options'); } } } break; case 'access_options': case 'cache_options': case 'exposed_form_options': case 'pager_options': case 'row_options': case 'style_options': // Submit plugin options. Every section with "_options" in it, belongs to // a plugin type, like "style_options". $plugin_type = str_replace('_options', '', $form_state['section']); if ($plugin = $this->getPlugin($plugin_type)) { $plugin_options = $this->getOption($plugin_type); $plugin->submitOptionsForm($form[$plugin_type . '_options'], $form_state); $plugin_options['options'] = $form_state['values'][$section]; $this->setOption($plugin_type, $plugin_options); } break; } foreach ($this->extender as $extender) { $extender->submitOptionsForm($form, $form_state); } }
/** * {@inheritdoc} */ public function query() { // Since attachment views don't validate the exposed input, parse the search // expression if required. if (!$this->parsed) { $this->queryParseSearchExpression($this->value); } $required = FALSE; if (!isset($this->searchQuery)) { $required = TRUE; } else { $words = $this->searchQuery->words(); if (empty($words)) { $required = TRUE; } } if ($required) { if ($this->operator == 'required') { $this->query->addWhere($this->options['group'], 'FALSE'); } } else { $search_index = $this->ensureMyTable(); $search_condition = db_and(); // Create a new join to relate the 'search_total' table to our current // 'search_index' table. $definition = array('table' => 'search_total', 'field' => 'word', 'left_table' => $search_index, 'left_field' => 'word'); $join = Views::pluginManager('join')->createInstance('standard', $definition); $search_total = $this->query->addRelationship('search_total', $join, $search_index); $this->search_score = $this->query->addField('', "{$search_index}.score * {$search_total}.count", 'score', array('function' => 'sum')); $search_condition->condition("{$search_index}.type", $this->searchType); $search_dataset = $this->query->addTable('node_search_dataset'); $conditions = $this->searchQuery->conditions(); $condition_conditions =& $conditions->conditions(); foreach ($condition_conditions as $key => &$condition) { // Make sure we just look at real conditions. if (is_numeric($key)) { // Replace the conditions with the table alias of views. $this->searchQuery->conditionReplaceString('d.', "{$search_dataset}.", $condition); } } $search_conditions =& $search_condition->conditions(); $search_conditions = array_merge($search_conditions, $condition_conditions); $this->query->addWhere($this->options['group'], $search_condition); $this->query->addGroupBy("{$search_index}.sid"); $matches = $this->searchQuery->matches(); $placeholder = $this->placeholder(); $this->query->addHavingExpression($this->options['group'], "COUNT(*) >= {$placeholder}", array($placeholder => $matches)); } // Set to NULL to prevent PDO exception when views object is cached. $this->searchQuery = NULL; }
/** * Generates a route entry for a given view and display. * * @param string $view_id * The ID of the view. * @param string $display_id * The current display ID. * * @return \Symfony\Component\Routing\Route * The route for the view. */ protected function getRoute($view_id, $display_id) { $defaults = array('_controller' => 'Drupal\\views\\Routing\\ViewPageController::handle', 'view_id' => $view_id, 'display_id' => $display_id, '_view_display_show_admin_links' => $this->getOption('show_admin_links')); // @todo How do we apply argument validation? $bits = explode('/', $this->getOption('path')); // @todo Figure out validation/argument loading. // Replace % with %views_arg for menu autoloading and add to the // page arguments so the argument actually comes through. $arg_counter = 0; $argument_ids = array_keys((array) $this->getOption('arguments')); $total_arguments = count($argument_ids); $argument_map = array(); // Replace arguments in the views UI (defined via %) with parameters in // routes (defined via {}). As a name for the parameter use arg_$key, so // it can be pulled in the views controller from the request. foreach ($bits as $pos => $bit) { if ($bit == '%') { // Generate the name of the parameter using the key of the argument // handler. $arg_id = 'arg_' . $arg_counter++; $bits[$pos] = '{' . $arg_id . '}'; $argument_map[$arg_id] = $arg_id; } elseif (strpos($bit, '%') === 0) { // Use the name defined in the path. $parameter_name = substr($bit, 1); $arg_id = 'arg_' . $arg_counter++; $argument_map[$arg_id] = $parameter_name; $bits[$pos] = '{' . $parameter_name . '}'; } } // Add missing arguments not defined in the path, but added as handler. while ($total_arguments - $arg_counter > 0) { $arg_id = 'arg_' . $arg_counter++; $bit = '{' . $arg_id . '}'; // In contrast to the previous loop add the defaults here, as % was not // specified, which means the argument is optional. $defaults[$arg_id] = NULL; $argument_map[$arg_id] = $arg_id; $bits[] = $bit; } // If this is to be a default tab, create the route for the parent path. if ($this->isDefaultTabPath()) { $bit = array_pop($bits); if (empty($bits)) { $bits[] = $bit; } } $route_path = '/' . implode('/', $bits); $route = new Route($route_path, $defaults); // Add access check parameters to the route. $access_plugin = $this->getPlugin('access'); if (!isset($access_plugin)) { // @todo Do we want to support a default plugin in getPlugin itself? $access_plugin = Views::pluginManager('access')->createInstance('none'); } $access_plugin->alterRouteDefinition($route); // Set the argument map, in order to support named parameters. $route->setOption('_view_argument_map', $argument_map); $route->setOption('_view_display_plugin_id', $this->getPluginId()); $route->setOption('_view_display_plugin_class', get_called_class()); $route->setOption('_view_display_show_admin_links', $this->getOption('show_admin_links')); // Store whether the view will return a response. $route->setOption('returns_response', !empty($this->getPluginDefinition()['returns_response'])); return $route; }
/** * {@inheritdoc} */ public function query() { // Figure out what base table this relationship brings to the party. $table_data = Views::viewsData()->get($this->definition['base']); $base_field = empty($this->definition['base field']) ? $table_data['table']['base']['field'] : $this->definition['base field']; $this->ensureMyTable(); $def = $this->definition; $def['table'] = $this->definition['base']; $def['field'] = $base_field; $def['left_table'] = $this->tableAlias; $def['left_field'] = $this->realField; $def['adjusted'] = TRUE; if (!empty($this->options['required'])) { $def['type'] = 'INNER'; } if (!empty($this->definition['extra'])) { $def['extra'] = $this->definition['extra']; } if (!empty($def['join_id'])) { $id = $def['join_id']; } else { $id = 'standard'; } $join = Views::pluginManager('join')->createInstance($id, $def); // use a short alias for this: $alias = $def['table'] . '_' . $this->table; $this->alias = $this->query->addRelationship($alias, $join, $this->definition['base'], $this->relationship); // Add access tags if the base table provide it. if (empty($this->query->options['disable_sql_rewrite']) && isset($table_data['table']['base']['access query tag'])) { $access_tag = $table_data['table']['base']['access query tag']; $this->query->addTag($access_tag); } }
/** * Adds an instance of a handler to the view. * * Items may be fields, filters, sort criteria, or arguments. * * @param string $display_id * The machine name of the display. * @param string $type * The type of handler being added. * @param string $table * The name of the table this handler is from. * @param string $field * The name of the field this handler is from. * @param array $options * (optional) Extra options for this instance. Defaults to an empty array. * @param string $id * (optional) A unique ID for this handler instance. Defaults to NULL, in * which case one will be generated. * * @return string * The unique ID for this handler instance. */ public function addHandler($display_id, $type, $table, $field, $options = array(), $id = NULL) { $types = $this::getHandlerTypes(); $this->setDisplay($display_id); $fields = $this->displayHandlers->get($display_id)->getOption($types[$type]['plural']); if (empty($id)) { $id = $this->generateHandlerId($field, $fields); } // If the desired type is not found, use the original value directly. $handler_type = !empty($types[$type]['type']) ? $types[$type]['type'] : $type; $fields[$id] = array('id' => $id, 'table' => $table, 'field' => $field) + $options; // Load the plugin ID if available. $data = Views::viewsData()->get($table); if (isset($data[$field][$handler_type]['id'])) { $fields[$id]['plugin_id'] = $data[$field][$handler_type]['id']; if ($definition = Views::pluginManager($handler_type)->getDefinition($fields[$id]['plugin_id'], FALSE)) { $fields[$id]['provider'] = isset($definition['provider']) ? $definition['provider'] : 'views'; } } $this->displayHandlers->get($display_id)->setOption($types[$type]['plural'], $fields); return $id; }
/** * Adds a new display handler to the view, automatically creating an ID. * * @param string $plugin_id * (optional) The plugin type from the Views plugin annotation. Defaults to * 'page'. * @param string $title * (optional) The title of the display. Defaults to NULL. * @param string $id * (optional) The ID to use, e.g., 'default', 'page_1', 'block_2'. Defaults * to NULL. * * @return string|false * The key to the display in $view->display, or FALSE if no plugin ID was * provided. */ public function addDisplay($plugin_id = 'page', $title = NULL, $id = NULL) { if (empty($plugin_id)) { return FALSE; } $plugin = Views::pluginManager('display')->getDefinition($plugin_id); if (empty($plugin)) { $plugin['title'] = t('Broken'); } if (empty($id)) { $id = $this->generateDisplayId($plugin_id); // Generate a unique human-readable name by inspecting the counter at the // end of the previous display ID, e.g., 'page_1'. if ($id !== 'default') { preg_match("/[0-9]+/", $id, $count); $count = $count[0]; } else { $count = ''; } if (empty($title)) { // If there is no title provided, use the plugin title, and if there are // multiple displays, append the count. $title = $plugin['title']; if ($count > 1) { $title .= ' ' . $count; } } } $display_options = array('display_plugin' => $plugin_id, 'id' => $id, 'display_title' => (string) $title, 'position' => $id === 'default' ? 0 : count($this->display), 'provider' => $plugin['provider'], 'display_options' => array()); // Add the display options to the view. $this->display[$id] = $display_options; return $id; }
/** * {@inheritdoc} */ public function submitOptionsForm(&$form, FormStateInterface $form_state) { // Not sure I like this being here, but it seems (?) like a logical place. $cache_plugin = $this->getPlugin('cache'); if ($cache_plugin) { $cache_plugin->cacheFlush(); } $section = $form_state->get('section'); switch ($section) { case 'display_id': if ($form_state->hasValue('display_id')) { $this->display['new_id'] = $form_state->getValue('display_id'); } break; case 'display_title': $this->display['display_title'] = $form_state->getValue('display_title'); $this->setOption('display_description', $form_state->getValue('display_description')); break; case 'query': $plugin = $this->getPlugin('query'); if ($plugin) { $plugin->submitOptionsForm($form['query']['options'], $form_state); $this->setOption('query', $form_state->getValue($section)); } break; case 'link_display': $this->setOption('link_url', $form_state->getValue('link_url')); case 'title': case 'css_class': case 'display_comment': case 'distinct': case 'group_by': $this->setOption($section, $form_state->getValue($section)); break; case 'rendering_language': $this->setOption('rendering_language', $form_state->getValue('rendering_language')); break; case 'use_ajax': case 'hide_attachment_summary': case 'show_admin_links': case 'exposed_block': $this->setOption($section, (bool) $form_state->getValue($section)); break; case 'use_more': $this->setOption($section, intval($form_state->getValue($section))); $this->setOption('use_more_always', intval($form_state->getValue('use_more_always'))); $this->setOption('use_more_text', $form_state->getValue('use_more_text')); break; case 'access': case 'cache': case 'exposed_form': case 'pager': case 'row': case 'style': $plugin_type = $section; $plugin_options = $this->getOption($plugin_type); $type = $form_state->getValue(array($plugin_type, 'type')); if ($plugin_options['type'] != $type) { /** @var \Drupal\views\Plugin\views\ViewsPluginInterface $plugin */ $plugin = Views::pluginManager($plugin_type)->createInstance($type); if ($plugin) { $plugin->init($this->view, $this, $plugin_options['options']); $plugin_options = array('type' => $type, 'options' => $plugin->options); $plugin->filterByDefinedOptions($plugin_options['options']); $this->setOption($plugin_type, $plugin_options); if ($plugin->usesOptions()) { $form_state->get('view')->addFormToStack('display', $this->display['id'], $plugin_type . '_options'); } } } break; case 'access_options': case 'cache_options': case 'exposed_form_options': case 'pager_options': case 'row_options': case 'style_options': // Submit plugin options. Every section with "_options" in it, belongs to // a plugin type, like "style_options". $plugin_type = str_replace('_options', '', $section); if ($plugin = $this->getPlugin($plugin_type)) { $plugin_options = $this->getOption($plugin_type); $plugin->submitOptionsForm($form[$plugin_type . '_options'], $form_state); $plugin_options['options'] = $form_state->getValue($section); $this->setOption($plugin_type, $plugin_options); } break; } $extender_options = $this->getOption('display_extenders'); foreach ($this->extenders as $extender) { $extender->submitOptionsForm($form, $form_state); $plugin_id = $extender->getPluginId(); $extender_options[$plugin_id] = $extender->options; } $this->setOption('display_extenders', $extender_options); }
/** * Set the display for this view and initialize the display handler. */ public function initDisplay() { if (isset($this->current_display)) { return TRUE; } // Initialize the display cache array. $this->displayHandlers = new DisplayPluginCollection($this, Views::pluginManager('display')); $this->current_display = 'default'; $this->display_handler = $this->displayHandlers->get('default'); return TRUE; }
/** * Get the display or row plugin, if it exists. */ public function getPlugin($type = 'argument_default', $name = NULL) { $options = array(); switch ($type) { case 'argument_default': $plugin_name = $this->options['default_argument_type']; $options_name = 'default_argument_options'; break; case 'argument_validator': $plugin_name = $this->options['validate']['type']; $options_name = 'validate_options'; break; case 'style': $plugin_name = $this->options['summary']['format']; $options_name = 'summary_options'; } if (!$name) { $name = $plugin_name; } // we only fetch the options if we're fetching the plugin actually // in use. if ($name == $plugin_name) { $options = $this->options[$options_name]; } $plugin = Views::pluginManager($type)->createInstance($name); if ($plugin) { $plugin->init($this->view, $this->displayHandler, $options); if ($type !== 'style') { // It's an argument_default/argument_validate plugin, so set the argument. $plugin->setArgument($this); } return $plugin; } }