The plugin that handles a block. More...

Inheritance diagram for views_plugin_display_block:

Public Member Functions
	option_definition ()
	Information about options for all kinds of purposes will be held here.
	execute_hook_block_list ($delta=0, $edit=array())
	The default block handler doesn't support configurable items, but extended block handlers might be able to do interesting stuff with it.
	execute ()
	The display block handler returns the structure necessary for a block.
	options_summary (&$categories, &$options)
	Provide the summary for page options in the views UI.
	block_caching_modes ()
	Provide a list of core's block caching modes.
	get_cache_type ()
	Provide a single method to figure caching type, keeping a sensible default for when it's unset.
	options_form (&$form, &$form_state)
	Provide the default form for setting options.
	options_submit (&$form, &$form_state)
	Perform any necessary changes to the form values prior to storage.
	uses_exposed ()
	Block views use exposed widgets only if AJAX is set.
	update_block_bid ($name, $old_delta, $delta)
	Update the block delta when you change the machine readable name of the display.
	save_block_cache ($delta, $cache_setting)
	Save the block cache setting in the blocks table if this block allready exists in the blocks table.
	init (&$view, &$display, $options=NULL)
	construct ()
	Views handlers use a special construct function so that we can more easily construct them with variable arguments.
	destroy ()
	is_default_display ()
	Determine if this display is the 'default' display which contains fallback settings.
	displays_exposed ()
	Determine if this display should display the exposed filters widgets, so the view will know whether or not to render them.
	use_ajax ()
	Does the display use AJAX?
	use_pager ()
	Does the display have a pager enabled?
	use_more ()
	Does the display have a more link enabled?
	use_group_by ()
	Does the display have groupby enabled?
	use_more_always ()
	Should the enabled display more link be shown when no more items?
	use_more_text ()
	Does the display have custom link text?
	accept_attachments ()
	Can this display accept attachments?
	attach_to ($display_id)
	Allow displays to attach to other views.
	defaultable_sections ($section=NULL)
	Static member function to list which sections are defaultable and what items each section contains.
	has_path ()
	Check to see if the display has a 'path' field.
	uses_link_display ()
	Check to see if the display has some need to link to another display.
	uses_exposed_form_in_block ()
	Check to see if the display can put the exposed formin a block.
	get_link_display ()
	Check to see which display to use when creating links within a view using this display.
	get_path ()
	Return the base path to use for this display.
	uses_breadcrumb ()
	Check to see if the display needs a breadcrumb.
	is_defaulted ($option)
	Determine if a given option is set to use the default display or the current display.
	get_option ($option)
	Intelligently get an option either from this display or from the default display, if directed to do so.
	uses_fields ()
	Determine if the display's style uses fields.
	get_plugin ($type= 'style', $name=NULL)
	Get the instance of a plugin, for example style or row.
&	get_handler ($type, $id)
	Get the handler object for a single handler.
	get_handlers ($type)
	Get a full array of handlers for $type.
	get_field_labels ()
	Retrieve a list of fields for the current display with the relationship associated if it exists.
	set_option ($option, $value)
	Intelligently set an option either from this display or from the default display, if directed to do so.
	override_option ($option, $value)
	Set an option and force it to be an override.
	option_link ($text, $section, $class= '', $title= '')
	Because forms may be split up into sections, this provides an easy URL to exactly the right section.
	get_arguments_tokens ()
	Returns to tokens for arguments.
	format_themes ($themes)
	Format a list of theme templates for output by the theme info helper.
	options_validate (&$form, &$form_state)
	Validate the options form.
	options_override ($form, &$form_state)
	If override/revert was clicked, perform the proper toggle.
	set_override ($section, $new_state=NULL)
	Flip the override setting for the given section.
	query ()
	Inject anything into the query that the display handler needs.
	render_filters ()
	Not all display plugins will support filtering.
	render_pager ()
	Not all display plugins will suppert pager rendering.
	render_more_link ()
	Render the 'more' link.
	render_header ()
	Legacy functions.
	render_footer ()
	Render the footer of the view.
	render_empty ()
	hook_block_list ($delta=0, $edit=array())
	If this display creates a block, implement one of these.
	hook_menu ()
	If this display creates a page with a menu item, implement it here.
	render ()
	Render this display.
	render_area ($area, $empty=FALSE)
	access ($account=NULL)
	Determine if the user has access to this display of the view.
	pre_execute ()
	Set up any variables on the view prior to execution.
	preview ()
	Fully render the display for the purposes of a live preview or some other AJAXy reason.
	get_style_type ()
	Displays can require a certain type of style plugin.
	validate ()
	Make sure the display and all associated handlers are valid.
	is_identifier_unique ($id, $identifier)
	Check if the provided identifier is unique.
	get_special_blocks ()
	Provide the block system with any exposed widget blocks for this display.
	view_special_blocks ($type)
	Render any special blocks provided for this display.
	export_option ($indent, $prefix, $storage, $option, $definition, $parents)
	Override of export_option().
	export_handler ($indent, $prefix, $storage, $option, $definition, $parents)
	Special method to export items that have handlers.
	export_style ($indent, $prefix, $storage, $option, $definition, $parents)
	Special handling for the style export.
	export_plugin ($indent, $prefix, $storage, $option, $definition, $parents)
	Special handling for plugin export.
	unpack_style ($indent, $prefix, $storage, $option, $definition, $parents)
	unpack_plugin (&$translatable, $storage, $option, $definition, $parents)
	Special handling for plugin unpacking.
	unpack_handler (&$translatable, $storage, $option, $definition, $parents)
	Special method to unpack items that have handlers.
	get_argument_text ()
	Provide some helpful text for the arguments.
	get_pager_text ()
	Provide some helpful text for pagers.
	theme_functions ()
	Provide a full list of possible theme templates used by this style.
	additional_theme_functions ()
	Provide a list of additional theme functions for the theme information page.
	summary_title ()
	Returns the summary of the settings in the display.
	plugin_title ()
	Return the human readable name of the display.
	options (&$options)
	Set default options on this object.
	set_default_options ()
	Set default options.
	_set_option_defaults (&$storage, $options, $level=0)
	unpack_options (&$storage, $options, $definition=NULL, $all=TRUE, $check=TRUE, $localization_keys=array())
	Unpack options over our existing defaults, drilling down into arrays so that defaults don't get totally blown away.
	set_definition ($definition)
	Let the handler know what its full definition is.
	export_options ($indent, $prefix)
	unpack_translatables (&$translatable, $parents=array())
	Unpacks each handler to store translatable texts.
	unpack_translatable (&$translatable, $storage, $option, $definition, $parents, $keys=array())
	Unpack a single option definition.
Public Attributes
	$view = NULL
	$handlers = array()
	$extender = array()
	Stores all available display extenders.
	$display = NULL
	$plugin_type = NULL
	The plugin type of this plugin, for example style or query.
	$options = array()
	Except for displays, options for the object will be held here.
	$definition

Detailed Description

The plugin that handles a block.

Definition at line 12 of file views_plugin_display_block.inc.

Member Function Documentation

views_plugin_display::accept_attachments ( ) [inherited]

Can this display accept attachments?

Definition at line 365 of file views_plugin_display.inc.

                                {
    if (empty($this->definition['accept attachments'])) {
      return FALSE;
    }
    if (!empty($this->view->argument) && $this->get_option('hide_attachment_summary')) {
      foreach ($this->view->argument as $argument_id => $argument) {
        if ($argument->needs_style_plugin() && empty($argument->argument_validated)) {
          return FALSE;
        }
      }
    }
    return TRUE;
  }

views_plugin_display::access ( $ account = NULL ) [inherited]

Determine if the user has access to this display of the view.

Definition at line 2548 of file views_plugin_display.inc.

References views_plugin_display::get_plugin().

Referenced by views_plugin_display_attachment::attach_to().

                                   {
    if (!isset($account)) {
      global $user;
      $account = $user;
    }

    // Full override.
    if (user_access('access all views', $account)) {
      return TRUE;
    }

    $plugin = $this->get_plugin('access');
    if ($plugin) {
      return $plugin->access($account);
    }

    // fallback to all access if no plugin.
    return TRUE;
  }

views_plugin::additional_theme_functions ( ) [inherited]

Provide a list of additional theme functions for the theme information page.

Definition at line 518 of file plugins.inc.

References views_theme_functions().

Referenced by views_plugin_display::options_form().

                                        {
    $funcs = array();
    if (!empty($this->definition['additional themes'])) {
      foreach ($this->definition['additional themes'] as $theme => $type) {
        $funcs[] = views_theme_functions($theme, $this->view, $this->display);
      }
    }
    return $funcs;
  }

views_plugin_display::attach_to ( $ display_id ) [inherited]

Allow displays to attach to other views.

Reimplemented in views_plugin_display_attachment, and views_plugin_display_feed.

Definition at line 382 of file views_plugin_display.inc.

{ }

views_plugin_display_block::block_caching_modes ( )

Provide a list of core's block caching modes.

Definition at line 104 of file views_plugin_display_block.inc.

Referenced by options_form(), and options_summary().

                                 {
    return array(
      DRUPAL_NO_CACHE => t('Do not cache'),
      DRUPAL_CACHE_GLOBAL => t('Cache once for everything (global)'),
      DRUPAL_CACHE_PER_PAGE => t('Per page'),
      DRUPAL_CACHE_PER_ROLE => t('Per role'),
      DRUPAL_CACHE_PER_ROLE | DRUPAL_CACHE_PER_PAGE => t('Per role per page'),
      DRUPAL_CACHE_PER_USER => t('Per user'),
      DRUPAL_CACHE_PER_USER | DRUPAL_CACHE_PER_PAGE => t('Per user per page'),
    );
  }

views_plugin_display::construct ( ) [inherited]

Views handlers use a special construct function so that we can more easily construct them with variable arguments.

Reimplemented from views_object.

Definition at line 221 of file views_plugin_display.inc.

References views_plugin_display::$extender, views_fetch_plugin_data(), views_get_enabled_display_extenders(), and vpr().

                       {
    // Load extenders as soon as possible
    $this->extender = array();
    $extenders = views_get_enabled_display_extenders();
    // If you update to the dev version the registry might not be loaded yet.
    if (!empty($extenders) && class_exists('views_plugin_display_extender')) {
      foreach ($extenders as $extender) {
        $data = views_fetch_plugin_data('display_extender', $extender);
        if (isset($data['handler']) && class_exists($data['handler'])) {
          $this->extender[$extender] = new $data['handler']($this->view, $this);
        }
        else {
          vpr('Invalid display extender @extender', array('@handler' => $extender));
        }
      }
    }
    parent::construct();
  }

views_plugin_display::defaultable_sections ( $ section = NULL ) [inherited]

Static member function to list which sections are defaultable and what items each section contains.

Reimplemented in views_plugin_display_feed.

Definition at line 388 of file views_plugin_display.inc.

Referenced by views_plugin_display::export_option(), views_plugin_display::options_form(), and views_plugin_display::set_override().

                                                 {
    $sections = array(
      'access' => array('access', 'access_options'),
      'access_options' => array('access', 'access_options'),
      'cache' => array('cache', 'cache_options'),
      'cache_options' => array('cache', 'cache_options'),
      'title' => array('title'),
      'css_class' => array('css_class'),
      'use_ajax' => array('use_ajax'),
      'hide_attachment_summary' => array('hide_attachment_summary'),
      'group_by' => array('group_by'),
      'query' => array('query'),
      'use_more' => array('use_more', 'use_more_always', 'use_more_text'),
      'link_display' => array('link_display', 'link_url'),

      // Force these to cascade properly.
      'style_plugin' => array('style_plugin', 'style_options', 'row_plugin', 'row_options'),
      'style_options' => array('style_plugin', 'style_options', 'row_plugin', 'row_options'),
      'row_plugin' => array('style_plugin', 'style_options', 'row_plugin', 'row_options'),
      'row_options' => array('style_plugin', 'style_options', 'row_plugin', 'row_options'),

      'pager' => array('pager', 'pager_options'),
      'pager_options' => array('pager', 'pager_options'),

      'exposed_form' => array('exposed_form', 'exposed_form_options'),
      'exposed_form_options' => array('exposed_form', 'exposed_form_options'),

      // These guys are special
      'header' => array('header'),
      'footer' => array('footer'),
      'empty' => array('empty'),
      'relationships' => array('relationships'),
      'fields' => array('fields'),
      'sorts' => array('sorts'),
      'arguments' => array('arguments'),
      'filters' => array('filters', 'filter_groups'),
    );

    // If the display cannot use a pager, then we cannot default it.
    if (empty($this->definition['use pager'])) {
      unset($sections['pager']);
      unset($sections['items_per_page']);
    }

    foreach ($this->extender as $extender) {
      $extender->defaultable_sections($sections, $section);
    }

    if ($section) {
      if (!empty($sections[$section])) {
        return $sections[$section];
      }
    }
    else {
      return $sections;
    }
  }

views_plugin_display::displays_exposed ( ) [inherited]

Determine if this display should display the exposed filters widgets, so the view will know whether or not to render them.

Regardless of what this function returns, exposed filters will not be used nor displayed unless uses_exposed() returns TRUE.

Reimplemented in views_plugin_display_attachment.

Definition at line 301 of file views_plugin_display.inc.

                              {
    return TRUE;
  }

views_plugin_display_block::execute ( )

The display block handler returns the structure necessary for a block.

Reimplemented from views_plugin_display.

Definition at line 50 of file views_plugin_display_block.inc.

References views_plugin_display::get_option().

                     {
    // Prior to this being called, the $view should already be set to this
    // display, and arguments should be set on the view.
    $info['content'] = $this->view->render();
    $info['subject'] = filter_xss_admin($this->view->get_title());
    if (!empty($this->view->result) || $this->get_option('empty') || !empty($this->view->style_plugin->definition['even empty'])) {
      return $info;
    }
  }

views_plugin_display_block::execute_hook_block_list	(	$	delta = `0`,
		$	edit = `array()`
	)

The default block handler doesn't support configurable items, but extended block handlers might be able to do interesting stuff with it.

Definition at line 27 of file views_plugin_display_block.inc.

References get_cache_type(), and views_plugin_display::get_option().

                                                                {
    $delta = $this->view->name . '-' . $this->display->id;
    $desc = $this->get_option('block_description');

    if (empty($desc)) {
      if ($this->display->display_title == $this->definition['title']) {
        $desc = t('View: @view', array('@view' => $this->view->get_human_name()));
      }
      else {
        $desc = t('View: @view: @display', array('@view' => $this->view->get_human_name(), '@display' => $this->display->display_title));
      }
    }
    return array(
      $delta => array(
        'info' => $desc,
        'cache' => $this->get_cache_type()
      ),
    );
  }

views_plugin_display::export_handler	(	$	indent,
		$	prefix,
		$	storage,
		$	option,
		$	definition,
		$	parents
	)			`[inherited]`

Special method to export items that have handlers.

This method was specified in the option_definition() as the method to utilize to export fields, filters, sort criteria, relationships and arguments. This passes the export off to the individual handlers so that they can export themselves properly.

Definition at line 2757 of file views_plugin_display.inc.

References views_plugin_display::use_group_by(), views_get_handler(), and views_object_types().

                                                                                      {
    $output = '';

    // cut the 's' off because the data is stored as the plural form but we need
    // the singular form. Who designed that anyway? Oh yeah, I did. :(
    if ($option != 'header' && $option != 'footer' && $option != 'empty') {
      $type = substr($option, 0, -1);
    }
    else {
      $type = $option;
    }
    $types = views_object_types();
    foreach ($storage[$option] as $id => $info) {
      if (!empty($types[$type]['type'])) {
        $handler_type = $types[$type]['type'];
      }
      else {
        $handler_type = $type;
      }
      // If aggregation is on, the group type might override the actual
      // handler that is in use. This piece of code checks that and,
      // if necessary, sets the override handler.
      $override = NULL;
      if ($this->use_group_by() && !empty($info['group_type'])) {
        if (empty($this->view->query)) {
          $this->view->init_query();
        }
        $aggregate = $this->view->query->get_aggregation_info();
        if (!empty($aggregate[$info['group_type']]['handler'][$type])) {
          $override = $aggregate[$info['group_type']]['handler'][$type];
        }
      }
      $handler = views_get_handler($info['table'], $info['field'], $handler_type, $override);
      if ($handler) {
        $handler->init($this->view, $info);
        $output .= $indent . '/* ' . $types[$type]['stitle'] . ': ' . $handler->ui_name() . " */\n";
        $output .= $handler->export_options($indent, $prefix . "['$option']['$id']");
      }

      // Prevent reference problems.
      unset($handler);
    }

    return $output;
  }

views_plugin_display::export_option	(	$	indent,
		$	prefix,
		$	storage,
		$	option,
		$	definition,
		$	parents
	)			`[inherited]`

Override of export_option().

Because displays do not want to export options that are NOT overridden from the default display, we need some special handling during the export process.

Reimplemented from views_object.

Definition at line 2728 of file views_plugin_display.inc.

References views_plugin_display::defaultable_sections(), views_plugin_display::is_default_display(), and views_plugin_display::is_defaulted().

                                                                                     {
    // The $prefix is wrong because we store our actual options a little differently:
    $prefix = '$handler->display->display_options';
    $output = '';
    if (!$parents && !$this->is_default_display()) {
      // Do not export items that are not overridden.
      if ($this->is_defaulted($option)) {
        return;
      }

      // If this is not defaulted and is overrideable, flip the switch to say this
      // is overridden.
      if ($this->defaultable_sections($option)) {
        $output .= $indent . $prefix . "['defaults']['$option'] = FALSE;\n";
      }
    }

    $output .= parent::export_option($indent, $prefix, $storage, $option, $definition, $parents);
    return $output;
  }

views_plugin_display::export_plugin	(	$	indent,
		$	prefix,
		$	storage,
		$	option,
		$	definition,
		$	parents
	)			`[inherited]`

Special handling for plugin export.

Plugins other than styles are stored in array with 'type' being the key to the plugin. For modern plugins, the options are stored in the 'options' array, but for legacy plugins (access and cache) options are stored as siblings to the type.

Definition at line 2849 of file views_plugin_display.inc.

References views_plugin::$plugin_type, and views_plugin_display::get_plugin().

                                                                                     {
    $output = '';
    $plugin_type = end($parents);
    $plugin = $this->get_plugin($plugin_type);
    if ($plugin) {
      // Write which plugin to use.
      $value = $storage[$option];
      $new_prefix = $prefix . "['$plugin_type']";

      $output .= $indent . $new_prefix . "['$option'] = '$value';\n";

      if ($plugin_type != 'access' && $plugin_type!= 'cache') {
        $new_prefix .= "['options']";
      }

      // Pass off to the plugin to export itself.
      $output .= $plugin->export_options($indent, $new_prefix);
    }

    return $output;
  }

views_plugin_display::export_style	(	$	indent,
		$	prefix,
		$	storage,
		$	option,
		$	definition,
		$	parents
	)			`[inherited]`

Special handling for the style export.

Styles are stored as style_plugin and style_options or row_plugin and row_options accordingly. The options are told not to export, and the export for the plugin should export both.

Definition at line 2810 of file views_plugin_display.inc.

References views_plugin_display::get_option(), and views_plugin_display::get_plugin().

                                                                                    {
    $output = '';
    $style_plugin = $this->get_plugin();
    if ($option == 'style_plugin') {
      $type = 'style';
      $options_field = 'style_options';
      $plugin = $style_plugin;
    }
    else {
      if (!$style_plugin || !$style_plugin->uses_row_plugin()) {
        return;
      }

      $type = 'row';
      $options_field = 'row_options';
      $plugin = $this->get_plugin('row');
      // If the style plugin doesn't use row plugins, don't even bother.
    }

    if ($plugin) {
      // Write which plugin to use.
      $value = $this->get_option($option);
      $output .= $indent . $prefix . "['$option'] = '$value';\n";

      // Pass off to the plugin to export itself.
      $output .= $plugin->export_options($indent, $prefix . "['$options_field']");
    }

    return $output;
  }

views_plugin_display::format_themes ( $ themes ) [inherited]

Format a list of theme templates for output by the theme info helper.

Definition at line 2111 of file views_plugin_display.inc.

Referenced by views_plugin_display::options_form().

                                  {
    $registry = $this->theme_registry;
    $extension = $this->theme_extension;

    $output = '';
    $picked = FALSE;
    foreach ($themes as $theme) {
      $template = strtr($theme, '_', '-') . $extension;
      if (!$picked && !empty($registry[$theme])) {
        $template_path = isset($registry[$theme]['path']) ? $registry[$theme]['path'] . '/' : './';
        if (file_exists($template_path . $template)) {
          $hint = t('File found in folder @template-path', array('@template-path' => $template_path));
          $template = '<strong title="'. $hint .'">' . $template . '</strong>';
        }
        else {
          $template = '<strong class="error">' . $template . ' ' . t('(File not found, in folder @template-path)', array('@template-path' => $template_path)) . '</strong>';
        }
        $picked = TRUE;
      }
      $fixed[] = $template;
    }

    return implode(', ', array_reverse($fixed));
  }

views_plugin_display::get_argument_text ( ) [inherited]

Provide some helpful text for the arguments.

The result should contain of an array with

filter value present: The title of the fieldset in the argument where you can configure what should be done with a given argument.
filter value not present: The tiel of the fieldset in the argument where you can configure what should be done if the argument does not exist.
description: A description about how arguments comes to the display. For example blocks don't get it from url.

Reimplemented in views_plugin_display_page.

Definition at line 2958 of file views_plugin_display.inc.

                               {
    return array(
      'filter value not present' => t('When the filter value is <em>NOT</em> available'),
      'filter value present' => t('When the filter value <em>IS</em> available or a default is provided'),
      'description' => t("This display does not have a source for contextual filters, so no contextual filter value will be available unless you select 'Provide default'."),
    );
  }

views_plugin_display::get_arguments_tokens ( ) [inherited]

Returns to tokens for arguments.

This function is similar to views_handler_field::get_render_tokens() but without fields tokens.

Definition at line 1025 of file views_plugin_display.inc.

Referenced by views_plugin_display::render_more_link().

                                  {
    $tokens = array();
    if (!empty($this->view->build_info['substitutions'])) {
      $tokens = $this->view->build_info['substitutions'];
    }
    $count = 0;
    foreach ($this->view->display_handler->get_handlers('argument') as $arg => $handler) {
      $token = '%' . ++$count;
      if (!isset($tokens[$token])) {
        $tokens[$token] = '';
      }

      // Use strip tags as there should never be HTML in the path.
      // However, we need to preserve special characters like " that
      // were removed by check_plain().
      $tokens['!' . $count] = isset($this->view->args[$count - 1]) ? strip_tags(decode_entities($this->view->args[$count - 1])) : '';
    }

    return $tokens;
  }

views_plugin_display_block::get_cache_type ( )

Provide a single method to figure caching type, keeping a sensible default for when it's unset.

Definition at line 120 of file views_plugin_display_block.inc.

References views_plugin_display::get_option().

Referenced by execute_hook_block_list(), options_form(), and options_summary().

                            {
    $cache_type = $this->get_option('block_caching');
    if (empty($cache_type)) {
      $cache_type = DRUPAL_NO_CACHE;
    }
    return $cache_type;
  }

views_plugin_display::get_field_labels ( ) [inherited]

Retrieve a list of fields for the current display with the relationship associated if it exists.

Definition at line 949 of file views_plugin_display.inc.

References views_object::$options, and views_plugin_display::get_handlers().

                              {
    $options = array();
    foreach ($this->get_handlers('relationship') as $relationship => $handler) {
      if ($label = $handler->label()) {
        $relationships[$relationship] = $label;
      }
      else {
        $relationships[$relationship] = $handler->ui_name();
      }
    }

    foreach ($this->get_handlers('field') as $id => $handler) {
      if ($label = $handler->label()) {
        $options[$id] = $label;
      }
      else {
        $options[$id] = $handler->ui_name();
      }
      if (!empty($handler->options['relationship']) && !empty($relationships[$handler->options['relationship']])) {
        $options[$id] = '(' . $relationships[$handler->options['relationship']] . ') ' . $options[$id];
      }
    }
    return $options;
  }

& views_plugin_display::get_handler	(	$	type,
		$	id
	)			`[inherited]`

Get the handler object for a single handler.

Definition at line 870 of file views_plugin_display.inc.

References views_plugin_display::get_handlers().

                                    {
    if (!isset($this->handlers[$type])) {
      $this->get_handlers($type);
    }

    if (isset($this->handlers[$type][$id])) {
      return $this->handlers[$type][$id];
    }

    // So we can return a reference.
    $null = NULL;
    return $null;
  }

views_plugin_display::get_handlers ( $ type ) [inherited]

Get a full array of handlers for $type.

This caches them.

Definition at line 887 of file views_plugin_display.inc.

References views_plugin_display::get_option(), views_plugin_display::use_group_by(), views_get_handler(), and views_object_types().

Referenced by views_plugin_display::get_field_labels(), views_plugin_display::get_handler(), views_plugin_display::is_identifier_unique(), views_plugin_display::options_form(), and views_plugin_display::validate().

                               {
    if (!isset($this->handlers[$type])) {
      $this->handlers[$type] = array();
      $types = views_object_types();
      $plural = $types[$type]['plural'];

      foreach ($this->get_option($plural) as $id => $info) {
        // If this is during form submission and there are temporary options
        // which can only appear if the view is in the edit cache, use those
        // options instead. This is used for AJAX multi-step stuff.
        if (isset($_POST['form_id']) && isset($this->view->temporary_options[$type][$id])) {
          $info = $this->view->temporary_options[$type][$id];
        }

        if ($info['id'] != $id) {
          $info['id'] = $id;
        }

        // If aggregation is on, the group type might override the actual
        // handler that is in use. This piece of code checks that and,
        // if necessary, sets the override handler.
        $override = NULL;
        if ($this->use_group_by() && !empty($info['group_type'])) {
          if (empty($this->view->query)) {
            $this->view->init_query();
          }
          $aggregate = $this->view->query->get_aggregation_info();
          if (!empty($aggregate[$info['group_type']]['handler'][$type])) {
            $override = $aggregate[$info['group_type']]['handler'][$type];
          }
        }

        if (!empty($types[$type]['type'])) {
          $handler_type = $types[$type]['type'];
        }
        else {
          $handler_type = $type;
        }

        $handler = views_get_handler($info['table'], $info['field'], $handler_type, $override);
        if ($handler) {
          // Special override for area types so they know where they come from.
          if ($handler_type == 'area') {
            $handler->handler_type = $type;
          }

          $handler->init($this->view, $info);
          $this->handlers[$type][$id] = &$handler;
        }

        // Prevent reference problems.
        unset($handler);
      }
    }

    return $this->handlers[$type];
  }

views_plugin_display::get_link_display ( ) [inherited]

Check to see which display to use when creating links within a view using this display.

Definition at line 729 of file views_plugin_display.inc.

References views_plugin_display::get_option().

Referenced by views_plugin_display::get_path(), and views_plugin_display::options_summary().

                              {
    $display_id = $this->get_option('link_display');
    // If unknown, pick the first one.
    if (empty($display_id) || empty($this->view->display[$display_id])) {
      foreach ($this->view->display as $display_id => $display) {
        if (!empty($display->handler) && $display->handler->has_path()) {
          return $display_id;
        }
      }
    }
    else {
      return $display_id;
    }
    // fall-through returns NULL
  }

views_plugin_display::get_option ( $ option ) [inherited]

Intelligently get an option either from this display or from the default display, if directed to do so.

Definition at line 784 of file views_plugin_display.inc.

References views_plugin_display::is_defaulted(), and views_object::options().

                               {
    if ($this->is_defaulted($option)) {
      return $this->default_display->get_option($option);
    }

    if (array_key_exists($option, $this->options)) {
      return $this->options[$option];
    }
  }

views_plugin_display::get_pager_text ( ) [inherited]

Provide some helpful text for pagers.

The result should contain of an array within

items per page title

Reimplemented in views_plugin_display_page.

Definition at line 2972 of file views_plugin_display.inc.

                            {
    return array(
      'items per page title' => t('Items to display'),
      'items per page description' => t('The number of items to display. Enter 0 for no limit.')
    );
  }

views_plugin_display::get_path ( ) [inherited]

Return the base path to use for this display.

This can be overridden for displays that do strange things with the path.

Definition at line 751 of file views_plugin_display.inc.

References views_plugin_display::get_link_display(), views_plugin_display::get_option(), and views_plugin_display::has_path().

Referenced by views_plugin_display_feed::attach_to(), and views_plugin_display::render_more_link().

                      {
    if ($this->has_path()) {
      return $this->get_option('path');
    }

    $display_id = $this->get_link_display();
    if ($display_id && !empty($this->view->display[$display_id]) && is_object($this->view->display[$display_id]->handler)) {
      return $this->view->display[$display_id]->handler->get_path();
    }
  }

views_plugin_display::get_plugin	(	$	type = `'style'`,
		$	name = `NULL`
	)			`[inherited]`

Get the instance of a plugin, for example style or row.

Parameters:

	string	$type The type of the plugin.
	string	$name The name of the plugin defined in hook_views_plugins.

Returns:: views_plugin|FALSE

Definition at line 814 of file views_plugin_display.inc.

References views_object::$options, views_plugin_display::get_option(), views_plugin_display::is_defaulted(), views_fetch_data(), and views_get_plugin().

                                                     {
    static $cache = array();
    if (!isset($cache[$type][$name])) {
      switch ($type) {
        case 'style':
        case 'row':
          $option_name = $type . '_plugin';
          $options = $this->get_option($type . '_options');
          if (!$name) {
            $name = $this->get_option($option_name);
          }

          break;
        case 'query':
          $views_data = views_fetch_data($this->view->base_table);
          $name = !empty($views_data['table']['base']['query class']) ? $views_data['table']['base']['query class'] : 'views_query';
        default:
          $option_name = $type;
          $options = $this->get_option($type);
          if (!$name) {
            $name = $options['type'];
          }

          // access & cache store their options as siblings with the
          // type; all others use an 'options' array.
          if ($type != 'access' && $type != 'cache') {
            $options = $options['options'];
          }
      }
      $plugin = views_get_plugin($type, $name);

      if (!$plugin) {
        return;
      }
      if ($type != 'query') {
        $plugin->init($this->view, $this->display, $options);
      }
      else {
        $display_id = $this->is_defaulted($option_name) ? $this->display->id : 'default';
        $plugin->localization_keys = array($display_id, $type);

        if (!isset($this->base_field)) {
          $views_data = views_fetch_data($this->view->base_table);
          $this->view->base_field = !empty($views_data['table']['base']['field']) ? $views_data['table']['base']['field'] : '';
        }
        $plugin->init($this->view->base_table, $this->view->base_field, $options);
      }
      $cache[$type][$name] = $plugin;
    }

    return $cache[$type][$name];
  }

views_plugin_display::get_special_blocks ( ) [inherited]

Provide the block system with any exposed widget blocks for this display.

Definition at line 2686 of file views_plugin_display.inc.

References views_plugin_display::uses_exposed_form_in_block().

                                {
    $blocks = array();

    if ($this->uses_exposed_form_in_block()) {
      $delta = '-exp-' . $this->view->name . '-' . $this->display->id;
      $desc = t('Exposed form: @view-@display_id', array('@view' => $this->view->name, '@display_id' => $this->display->id));

      $blocks[$delta] = array(
        'info' => $desc,
        'cache' => DRUPAL_NO_CACHE,
      );
    }

    return $blocks;
  }

views_plugin_display::get_style_type ( ) [inherited]

Displays can require a certain type of style plugin.

By default, they will be 'normal'.

Reimplemented in views_plugin_display_feed.

Definition at line 2607 of file views_plugin_display.inc.

Referenced by views_plugin_display::options_form().

{ return 'normal'; }

views_plugin_display::has_path ( ) [inherited]

Check to see if the display has a 'path' field.

This is a pure function and not just a setting on the definition because some displays (such as a panel pane) may have a path based upon configuration.

By default, displays do not have a path.

Reimplemented in views_plugin_display_page.

Definition at line 704 of file views_plugin_display.inc.

Referenced by views_plugin_display::get_path(), views_plugin_display::uses_exposed_form_in_block(), views_plugin_display::uses_link_display(), and views_plugin_display::validate().

{ return FALSE; }

views_plugin_display::hook_block_list	(	$	delta = `0`,
		$	edit = `array()`
	)			`[inherited]`

If this display creates a block, implement one of these.

Definition at line 2522 of file views_plugin_display.inc.

{ return array(); }

views_plugin_display::hook_menu ( ) [inherited]

If this display creates a page with a menu item, implement it here.

Definition at line 2527 of file views_plugin_display.inc.

{ return array(); }

views_plugin_display::is_default_display ( ) [inherited]

Determine if this display is the 'default' display which contains fallback settings.

Reimplemented in views_plugin_display_default.

Definition at line 264 of file views_plugin_display.inc.

Referenced by views_plugin_display::export_option(), views_plugin_display::is_defaulted(), and views_plugin_display::option_definition().

{ return FALSE; }

views_plugin_display::is_defaulted ( $ option ) [inherited]

Determine if a given option is set to use the default display or the current display.

Returns:: TRUE for the default display

Definition at line 776 of file views_plugin_display.inc.

References views_plugin_display::is_default_display(), and views_object::options().

Referenced by views_plugin_display::export_option(), views_plugin_display::get_option(), views_plugin_display::get_plugin(), and views_plugin_display::set_option().

                                 {
    return !$this->is_default_display() && !empty($this->default_display) && !empty($this->options['defaults'][$option]);
  }

views_plugin_display::is_identifier_unique	(	$	id,
		$	identifier
	)			`[inherited]`

Check if the provided identifier is unique.

Definition at line 2670 of file views_plugin_display.inc.

References views_plugin_display::get_handlers(), and views_object_types().

                                                  {
    foreach (views_object_types() as $type => $info) {
      foreach ($this->get_handlers($type) as $key => $handler) {
        if ($handler->can_expose() && $handler->is_exposed()) {
          if ($id != $key && $identifier == $handler->options['expose']['identifier']) {
            return FALSE;
          }
        }
      }
    }
    return TRUE;
  }

views_plugin_display_block::option_definition ( )

Information about options for all kinds of purposes will be held here.

 'option_name' => array(
  - 'default' => default value,
  - 'translatable' => TRUE/FALSE (wrap in t() on export if true),
  - 'contains' => array of items this contains, with its own defaults, etc.
      If contains is set, the default will be ignored and assumed to
      be array()

  ),

Each option may have any of the following functions:

export_option_OPTIONNAME -- Special export handling if necessary.
translate_option_OPTIONNAME -- Special handling for translating data within the option, if necessary.

Reimplemented from views_plugin_display.

Definition at line 13 of file views_plugin_display_block.inc.

References views_object::$options.

                               {
    $options = parent::option_definition();

    $options['block_description'] = array('default' => '', 'translatable' => TRUE);
    $options['block_caching'] = array('default' => DRUPAL_NO_CACHE);

    return $options;
  }

views_plugin_display::option_link	(	$	text,
		$	section,
		$	class = `''`,
		$	title = `''`
	)			`[inherited]`

Because forms may be split up into sections, this provides an easy URL to exactly the right section.

Don't override this.

Definition at line 1002 of file views_plugin_display.inc.

References views_add_js().

Referenced by views_plugin_display::options_form().

                                                                  {
    views_add_js('ajax');
    if (!empty($class)) {
      $text = '<span>' . $text . '</span>';
    }

    if (!trim($text)) {
      $text = t('Broken field');
    }

    if (empty($title)) {
      $title = $text;
    }

    return l($text, 'admin/structure/views/nojs/display/' . $this->view->name . '/' . $this->display->id . '/' . $section, array('attributes' => array('class' => 'views-ajax-link ' . $class, 'title' => $title, 'id' => drupal_html_id('views-' . $this->display->id . '-' . $section)), 'html' => TRUE));
  }

views_object::options ( &$ options ) [inherited]

Set default options on this object.

Called by the constructor in a complex chain to deal with backward compatibility.

Reimplemented in views_plugin_style_default.

Definition at line 60 of file base.inc.

{ }

views_plugin_display_block::options_form	(	&$	form,
		&$	form_state
	)

Provide the default form for setting options.

Reimplemented from views_plugin_display.

Definition at line 131 of file views_plugin_display_block.inc.

References block_caching_modes(), get_cache_type(), and views_plugin_display::get_option().

                                              {
    parent::options_form($form, $form_state);
    // It is very important to call the parent function here:
    parent::options_form($form, $form_state);

    switch ($form_state['section']) {
      case 'block_description':
        $form['#title'] .= t('Block admin description');
        $form['block_description'] = array(
          '#type' => 'textfield',
          '#description' => t('This will appear as the name of this block in administer >> structure >> blocks.'),
          '#default_value' => $this->get_option('block_description'),
        );
        break;
      case 'block_caching':
        $form['#title'] .= t('Block caching type');

        $form['block_caching'] = array(
          '#type' => 'radios',
          '#description' => t("This sets the default status for Drupal's built-in block caching method; this requires that caching be turned on in block administration, and be careful because you have little control over when this cache is flushed."),
          '#options' => $this->block_caching_modes(),
          '#default_value' => $this->get_cache_type(),
        );
        break;
    }
  }

views_plugin_display::options_override	(	$	form,
		&$	form_state
	)			`[inherited]`

If override/revert was clicked, perform the proper toggle.

Definition at line 2411 of file views_plugin_display.inc.

References views_plugin_display::set_override().

                                                 {
    $this->set_override($form_state['section']);
  }

views_plugin_display_block::options_submit	(	&$	form,
		&$	form_state
	)

Perform any necessary changes to the form values prior to storage.

There is no need for this function to actually store the data.

Reimplemented from views_plugin_display.

Definition at line 162 of file views_plugin_display_block.inc.

References save_block_cache(), views_plugin_display::set_option(), and update_block_bid().

                                                {
    // It is very important to call the parent function here:
    parent::options_submit($form, $form_state);
    switch ($form_state['section']) {
      case 'display_id':
        $this->update_block_bid($form_state['view']->name, $this->display->id, $this->display->new_id);
        break;
      case 'block_description':
        $this->set_option('block_description', $form_state['values']['block_description']);
        break;
      case 'block_caching':
        $this->set_option('block_caching', $form_state['values']['block_caching']);
        $this->save_block_cache($form_state['view']->name . '-'. $form_state['display_id'], $form_state['values']['block_caching']);
        break;
    }
  }

views_plugin_display_block::options_summary	(	&$	categories,
		&$	options
	)

Provide the summary for page options in the views UI.

This output is returned as an array.

Reimplemented from views_plugin_display.

Definition at line 65 of file views_plugin_display_block.inc.

References views_object::$options, block_caching_modes(), get_cache_type(), views_plugin_display::get_option(), and views_ui_truncate().

                                                    {
    // It is very important to call the parent function here:
    parent::options_summary($categories, $options);

    $categories['block'] = array(
      'title' => t('Block settings'),
      'column' => 'second',
      'build' => array(
        '#weight' => -10,
      ),
    );

    $block_description = strip_tags($this->get_option('block_description'));
    if (empty($block_description)) {
      $block_description = t('None');
    }

    $options['block_description'] = array(
      'category' => 'block',
      'title' => t('Block name'),
      'value' => views_ui_truncate($block_description, 24),
    );

    $cache_type = $this->get_option('block_caching');
    if (empty($cache_type)) {
      $cache_type = DRUPAL_NO_CACHE;
    }

    $types = $this->block_caching_modes();
    $options['block_caching'] = array(
      'category' => 'other',
      'title' => t('Block caching'),
      'value' => $types[$this->get_cache_type()],
    );
  }

views_plugin_display::options_validate	(	&$	form,
		&$	form_state
	)			`[inherited]`

Validate the options form.

Reimplemented from views_plugin.

Reimplemented in views_plugin_display_page.

Definition at line 2139 of file views_plugin_display.inc.

References views_plugin_display::get_plugin().

                                                  {
    switch ($form_state['section']) {
      case 'display_title':
        if (empty($form_state['values']['display_title'])) {
          form_error($form['display_title'], t('Display title may not be empty.'));
        }
        break;
      case 'css_class':
        $css_class = $form_state['values']['css_class'];
        if (preg_match('/[^a-zA-Z0-9-_ ]/', $css_class)) {
          form_error($form['css_class'], t('CSS classes must be alphanumeric or dashes only.'));
        }
      break;
      case 'display_id':
        if ($form_state['values']['display_id']) {
          if (preg_match('/[^a-z0-9_]/', $form_state['values']['display_id'])) {
            form_error($form['display_id'], t('Display name must be letters, numbers, or underscores only.'));
          }

          foreach ($this->view->display as $id => $display) {
            if ($id != $this->view->current_display && ($form_state['values']['display_id'] == $id || (isset($display->new_id) && $form_state['values']['display_id'] == $display->new_id))) {
              form_error($form['display_id'], t('Display id should be unique.'));
            }
          }
        }
        break;
      case 'style_options':
        $style = TRUE;
      case 'row_options':
        // if row, $style will be empty.
        $plugin = $this->get_plugin(empty($style) ? 'row' : 'style');
        if ($plugin) {
          $plugin->options_validate($form[$form_state['section']], $form_state);
        }
        break;
      case 'access_options':
        $plugin = $this->get_plugin('access');
        if ($plugin) {
          $plugin->options_validate($form['access_options'], $form_state);
        }
        break;
      case 'query':
        if ($this->view->query) {
          $this->view->query->options_validate($form['query'], $form_state);
        }
        break;
      case 'cache_options':
        $plugin = $this->get_plugin('cache');
        if ($plugin) {
          $plugin->options_validate($form['cache_options'], $form_state);
        }
        break;
      case 'exposed_form_options':
        $plugin = $this->get_plugin('exposed_form');
        if ($plugin) {
          $plugin->options_validate($form['exposed_form_options'], $form_state);
        }
        break;
      case 'pager_options':
        $plugin = $this->get_plugin('pager');
        if ($plugin) {
          $plugin->options_validate($form['pager_options'], $form_state);
        }
        break;
    }

    foreach ($this->extender as $extender) {
      $extender->options_validate($form, $form_state);
    }
  }

views_plugin_display::override_option	(	$	option,
		$	value
	)			`[inherited]`

Set an option and force it to be an override.

Definition at line 993 of file views_plugin_display.inc.

References views_plugin_display::set_option(), and views_plugin_display::set_override().

                                            {
    $this->set_override($option, FALSE);
    $this->set_option($option, $value);
  }

views_plugin::plugin_title ( ) [inherited]

Return the human readable name of the display.

This appears on the ui beside each plugin and beside the settings link.

Definition at line 548 of file plugins.inc.

                          {
    if (isset($this->definition['short title'])) {
      return check_plain($this->definition['short title']);
    }
    return check_plain($this->definition['title']);
  }

views_plugin_display::pre_execute ( ) [inherited]

Set up any variables on the view prior to execution.

These are separated from execute because they are extremely common and unlikely to be overridden on an individual display.

Definition at line 2573 of file views_plugin_display.inc.

References views_plugin_display::get_plugin(), views_plugin_display::use_ajax(), views_plugin_display::use_more(), views_plugin_display::use_more_always(), and views_plugin_display::uses_exposed().

                         {
    $this->view->set_use_ajax($this->use_ajax());
    if ($this->use_more() && !$this->use_more_always()) {
      $this->view->get_total_rows = TRUE;
    }
    $this->view->init_handlers();
    if ($this->uses_exposed()) {
      $exposed_form = $this->get_plugin('exposed_form');
      $exposed_form->pre_execute();
    }

    foreach ($this->extender as $extender) {
      $extender->pre_execute();
    }
  }

views_plugin_display::preview ( ) [inherited]

Fully render the display for the purposes of a live preview or some other AJAXy reason.

Reimplemented in views_plugin_display_feed.

Definition at line 2601 of file views_plugin_display.inc.

{ return $this->view->render(); }

views_plugin_display::query ( ) [inherited]

Inject anything into the query that the display handler needs.

Reimplemented from views_plugin.

Definition at line 2448 of file views_plugin_display.inc.

                   {
    foreach ($this->extender as $extender) {
      $extender->query();
    }
  }

views_plugin_display::render ( ) [inherited]

Render this display.

Reimplemented in views_plugin_display_feed.

Definition at line 2532 of file views_plugin_display.inc.

References views_plugin::theme_functions().

                    {
    return theme($this->theme_functions(), array('view' => $this->view));
  }

views_plugin_display::render_filters ( ) [inherited]

Not all display plugins will support filtering.

Definition at line 2457 of file views_plugin_display.inc.

{ }

views_plugin_display::render_footer ( ) [inherited]

Render the footer of the view.

Definition at line 2510 of file views_plugin_display.inc.

                           {
    $empty = !empty($this->view->result);
    return $this->render_area('footer', $empty);
  }

views_plugin_display::render_header ( ) [inherited]

Legacy functions.

Render the header of the view.

Definition at line 2502 of file views_plugin_display.inc.

                           {
    $empty = !empty($this->view->result);
    return $this->render_area('header', $empty);
  }

views_plugin_display::render_more_link ( ) [inherited]

Render the 'more' link.

Definition at line 2469 of file views_plugin_display.inc.

References views_plugin_display::get_arguments_tokens(), views_plugin_display::get_option(), views_plugin_display::get_path(), views_plugin_display::use_more(), views_plugin_display::use_more_always(), views_plugin_display::use_more_text(), and views_theme_functions().

                              {
    if ($this->use_more() && ($this->use_more_always() || (!empty($this->view->query->pager) && $this->view->query->pager->has_more_records()))) {
      $path = $this->get_path();

      if ($this->get_option('link_display') == 'custom_url' && $override_path = $this->get_option('link_url')) {
        $tokens = $this->get_arguments_tokens();
        $path = strtr($override_path, $tokens);
      }

      if ($path) {
        if (empty($override_path)) {
          $path = $this->view->get_url(NULL, $path);
        }
        $url_options = array();
        if (!empty($this->view->exposed_raw_input)) {
          $url_options['query'] = $this->view->exposed_raw_input;
        }
        $theme = views_theme_functions('views_more', $this->view, $this->display);
        $path = check_url(url($path, $url_options));

        return theme($theme, array('more_url' => $path, 'link_text' => check_plain($this->use_more_text()), 'view' => $this->view));
      }
    }
  }

views_plugin_display::render_pager ( ) [inherited]

Not all display plugins will suppert pager rendering.

Reimplemented in views_plugin_display_attachment.

Definition at line 2462 of file views_plugin_display.inc.

                          {
    return TRUE;
  }

views_plugin_display_block::save_block_cache	(	$	delta,
		$	cache_setting
	)

Save the block cache setting in the blocks table if this block allready exists in the blocks table.

Dirty fix untill http://drupal.org/node/235673 gets in.

Definition at line 221 of file views_plugin_display_block.inc.

Referenced by options_submit().

                                                    {
    if (strlen($delta) >= 32) {
      $delta = md5($delta);
    }
    if (db_table_exists('block') && $bid = db_query("SELECT bid FROM {block} WHERE module = 'views' AND delta = :delta", array(
        ':delta' => $delta))->fetchField()) {
      db_update('block')
        ->fields(array(
        'cache' => $cache_setting,
        ))
        ->condition('module','views')
        ->condition('delta', $delta)
        ->execute();
    }
  }

views_object::set_default_options ( ) [inherited]

Set default options.

For backward compatibility, it sends the options array; this is a feature that will likely disappear at some point.

Definition at line 67 of file base.inc.

References views_object::option_definition(), and views_object::options().

Referenced by views_object::construct().

                                 {
    $this->_set_option_defaults($this->options, $this->option_definition());

    // Retained for complex defaults plus backward compatibility.
    $this->options($this->options);
  }

views_object::set_definition ( $ definition ) [inherited]

Let the handler know what its full definition is.

Definition at line 173 of file base.inc.

                                       {
    $this->definition = $definition;
    if (isset($definition['field'])) {
      $this->real_field = $definition['field'];
    }
  }

views_plugin_display::set_option	(	$	option,
		$	value
	)			`[inherited]`

Intelligently set an option either from this display or from the default display, if directed to do so.

Definition at line 978 of file views_plugin_display.inc.

References views_plugin_display::is_defaulted(), and views_object::options().

Referenced by views_plugin_display_page::options_submit(), views_plugin_display_feed::options_submit(), options_submit(), views_plugin_display_attachment::options_submit(), views_plugin_display::options_submit(), and views_plugin_display::override_option().

                                       {
    if ($this->is_defaulted($option)) {
      return $this->default_display->set_option($option, $value);
    }

    // Set this in two places: On the handler where we'll notice it
    // but also on the display object so it gets saved. This should
    // only be a temporary fix.
    $this->display->display_options[$option] = $value;
    return $this->options[$option] = $value;
  }

views_plugin_display::set_override	(	$	section,
		$	new_state = `NULL`
	)			`[inherited]`

Flip the override setting for the given section.

Definition at line 2418 of file views_plugin_display.inc.

References views_object::$options, views_plugin_display::defaultable_sections(), views_plugin_display::get_option(), and views_object::options().

Referenced by views_plugin_display::options_override(), and views_plugin_display::override_option().

                                                     {
    $options = $this->defaultable_sections($section);
    if (!$options) {
      return;
    }

    if (!isset($new_state)) {
      $new_state = empty($this->options['defaults'][$section]);
    }

    // For each option that is part of this group, fix our settings.
    foreach ($options as $option) {
      if ($new_state) {
        // Revert to defaults.
        unset($this->options[$option]);
        unset($this->display->display_options[$option]);
      }
      else {
        // copy existing values into our display.
        $this->options[$option] = $this->get_option($option);
        $this->display->display_options[$option] = $this->options[$option];
      }
      $this->options['defaults'][$option] = $new_state;
      $this->display->display_options['defaults'][$option] = $new_state;
    }
  }

views_plugin::summary_title ( ) [inherited]

Returns the summary of the settings in the display.

Reimplemented in views_plugin_row_comment_view, views_plugin_row_node_rss, views_plugin_row_node_view, views_plugin_row_user_view, views_plugin_access, views_plugin_access_none, views_plugin_access_perm, views_plugin_access_role, views_plugin_cache, views_plugin_cache_none, views_plugin_cache_time, views_plugin_pager, views_plugin_pager_full, views_plugin_pager_mini, views_plugin_pager_none, views_plugin_pager_some, and views_plugin_query.

Definition at line 540 of file plugins.inc.

                           {
    return t('Settings');
  }

views_plugin::theme_functions ( ) [inherited]

Provide a full list of possible theme templates used by this style.

Definition at line 511 of file plugins.inc.

References views_theme_functions().

Referenced by views_plugin_display::options_form(), views_plugin_style_summary::render(), views_plugin_style_rss::render(), views_plugin_row::render(), views_plugin_display::render(), views_plugin_row_search_view::render(), and views_plugin_style::render_grouping_sets().

                             {
    return views_theme_functions($this->definition['theme'], $this->view, $this->display);
  }

views_plugin_display::unpack_handler	(	&$	translatable,
		$	storage,
		$	option,
		$	definition,
		$	parents
	)			`[inherited]`

Special method to unpack items that have handlers.

This method was specified in the option_definition() as the method to utilize to export fields, filters, sort criteria, relationships and arguments. This passes the export off to the individual handlers so that they can export themselves properly.

Definition at line 2915 of file views_plugin_display.inc.

References views_get_handler(), and views_object_types().

                                                                                    {
    $output = '';

    // cut the 's' off because the data is stored as the plural form but we need
    // the singular form. Who designed that anyway? Oh yeah, I did. :(
    if ($option != 'header' && $option != 'footer' && $option != 'empty') {
      $type = substr($option, 0, -1);
    }
    else {
      $type = $option;
    }
    $types = views_object_types();
    foreach ($storage[$option] as $id => $info) {
      if (!empty($types[$type]['type'])) {
        $handler_type = $types[$type]['type'];
      }
      else {
        $handler_type = $type;
      }
      $handler = views_get_handler($info['table'], $info['field'], $handler_type);
      if ($handler) {
        $handler->init($this->view, $info);
        $handler->unpack_translatables($translatable, array_merge($parents, array($type, $info['table'], $info['id'])));
      }

      // Prevent reference problems.
      unset($handler);
    }

    return $output;
  }

views_object::unpack_options	(	&$	storage,
		$	options,
		$	definition = `NULL`,
		$	all = `TRUE`,
		$	check = `TRUE`,
		$	localization_keys = `array()`
	)			`[inherited]`

Unpack options over our existing defaults, drilling down into arrays so that defaults don't get totally blown away.

Definition at line 93 of file base.inc.

References views_object::$options, and views_object::option_definition().

Referenced by views_plugin_style::init(), views_plugin_row::init(), views_plugin_query::init(), views_plugin_pager::init(), views_plugin_exposed_form::init(), views_plugin_cache::init(), views_plugin_argument_validate::init(), views_plugin_argument_default::init(), views_plugin_access::init(), and views_handler::init().

                                                                                                                             {
    if ($check && !is_array($options)) {
      return;
    }

    if (!isset($definition)) {
      $definition = $this->option_definition();
    }

    if (!empty($this->view)) {
      // Ensure we have a localization plugin.
      $this->view->init_localization();

      // Set up default localization keys. Handlers and such set this for us
      if (empty($localization_keys) && isset($this->localization_keys)) {
        $localization_keys = $this->localization_keys;
      }
      // but plugins don't because there isn't a common init() these days.
      else if (!empty($this->is_plugin)) {
        if ($this->plugin_type != 'display') {
          $localization_keys = array($this->view->current_display);
          $localization_keys[] = $this->plugin_type;
        }
      }
    }

    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] = array();
        }

        // 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->unpack_options($storage[$key], $value, isset($definition[$key]['contains']) ? $definition[$key]['contains'] : array(), $all, FALSE, array_merge($localization_keys, array($key)));
      }
      // Don't localize strings during editing. When editing, we need to work with
      // the original data, not the translated version.
      else if (empty($this->view->editing) && !empty($definition[$key]['translatable']) && !empty($value) || !empty($definition['contains'][$key]['translatable']) && !empty($value)) {
        if (!empty($this->view) && $this->view->is_translatable()) {
          // Allow other modules to make changes to the string before it's
          // sent for translation.
          // The $keys array is built from the view name, any localization keys
          // sent in, and the name of the property being processed.
          $format = NULL;
          if (isset($definition[$key]['format_key']) && isset($options[$definition[$key]['format_key']])) {
            $format = $options[$definition[$key]['format_key']];
          }
          $translation_data = array(
            'value' => $value,
            'format' => $format,
            'keys' => array_merge(array($this->view->name), $localization_keys, array($key)),
          );
          $storage[$key] = $this->view->localization_plugin->translate($translation_data);
        }
        // Otherwise, this is a code-based string, so we can use t().
        else {
          $storage[$key] = t($value);
        }
      }
      else if ($all || !empty($definition[$key])) {
        $storage[$key] = $value;
      }
    }
  }

views_plugin_display::unpack_plugin	(	&$	translatable,
		$	storage,
		$	option,
		$	definition,
		$	parents
	)			`[inherited]`

Special handling for plugin unpacking.

Definition at line 2898 of file views_plugin_display.inc.

References views_plugin::$plugin_type, and views_plugin_display::get_plugin().

                                                                                   {
    $plugin_type = end($parents);
    $plugin = $this->get_plugin($plugin_type);
    if ($plugin) {
      // Write which plugin to use.
      return $plugin->unpack_translatables($translatable, $parents);
    }
  }

views_object::unpack_translatable	(	&$	translatable,
		$	storage,
		$	option,
		$	definition,
		$	parents,
		$	keys = `array()`
	)			`[inherited]`

Unpack a single option definition.

This function run's through all suboptions recursive.

Parameters:

	$translatable	Stores all available translatable items.
	$storage
	$option
	$definition
	$parents
	$keys

Definition at line 275 of file base.inc.

References views_object::$options.

Referenced by views_object::unpack_translatables().

                                                                                                          {
    // Do not export options for which we have no settings.
    if (!isset($storage[$option])) {
      return;
    }

    // Special handling for some items
    if (isset($definition['unpack_translatable']) && method_exists($this, $definition['unpack_translatable'])) {
      return $this->{$definition['unpack_translatable']}($translatable, $storage, $option, $definition, $parents, $keys);
    }

    if (isset($definition['translatable'])) {
      if ($definition['translatable'] === FALSE) {
        return;
      }
    }

    // Add the current option to the parents tree.
    $parents[] = $option;

    // If it has child items, unpack those separately.
    if (isset($definition['contains'])) {
      foreach ($definition['contains'] as $sub_option => $sub_definition) {
        $translation_keys = array_merge($keys, array($sub_option));
        $this->unpack_translatable($translatable, $storage[$option], $sub_option, $sub_definition, $parents, $translation_keys);
      }
    }

    // @todo Figure out this double definition stuff.
    $options = $storage[$option];
    if (is_array($options)) {
      foreach ($options as $key => $value) {
        $translation_keys = array_merge($keys, array($key));
        if (is_array($value)) {
          $this->unpack_translatable($translatable, $options, $key, $definition, $parents, $translation_keys);
        }
        else if (!empty($definition[$key]['translatable']) && !empty($value)) {
          // Build source data and add to the array
          $format = NULL;
          if (isset($definition['format_key']) && isset($options[$definition['format_key']])) {
            $format = $options[$definition['format_key']];
          }
          $translatable[] = array(
            'value' => $value,
            'keys' => $translation_keys,
            'format' => $format,
          );
        }
      }
    }
    else if (!empty($definition['translatable']) && !empty($options)) {
      $value = $options;
      // Build source data and add to the array
      $format = NULL;
      if (isset($definition['format_key']) && isset($storage[$definition['format_key']])) {
        $format = $options[$definition['format_key']];
      }
      $translatable[] = array(
        'value' => $value,
        'keys' => isset($translation_keys) ? $translation_keys : $parents,
        'format' => $format,
      );
    }
  }

views_object::unpack_translatables	(	&$	translatable,
		$	parents = `array()`
	)			`[inherited]`

Unpacks each handler to store translatable texts.

Definition at line 256 of file base.inc.

References views_object::option_definition(), views_object::options(), and views_object::unpack_translatable().

                                                                    {
    foreach ($this->option_definition() as $option => $definition) {
      $this->unpack_translatable($translatable, $this->options, $option, $definition, $parents, array());
    }
  }

views_plugin_display_block::update_block_bid	(	$	name,
		$	old_delta,
		$	delta
	)

Update the block delta when you change the machine readable name of the display.

Definition at line 193 of file views_plugin_display_block.inc.

Referenced by options_submit().

                                                       {
    $old_hashes = $hashes = variable_get('views_block_hashes', array());

    $old_delta = $name . '-' . $old_delta;
    $delta = $name . '-' . $delta;
    if (strlen($old_delta) >= 32) {
      $old_delta = md5($old_delta);
      unset($hashes[$old_delta]);
    }
    if (strlen($delta) >= 32) {
      $md5_delta = md5($delta);
      $hashes[$md5_delta] = $delta;
      $delta = $md5_delta;
    }
    db_update('block')
      ->fields(array('delta' => $delta))
      ->condition('delta', $old_delta)
      ->execute();

    // Update the hashes if needed.
    if ($hashes != $old_hashes) {
      variable_set('views_block_hashes', $hashes);
    }
  }

views_plugin_display::use_ajax ( ) [inherited]

Does the display use AJAX?

Definition at line 308 of file views_plugin_display.inc.

References views_plugin_display::get_option().

Referenced by views_plugin_display::pre_execute(), and uses_exposed().

                      {
    if (!empty($this->definition['use ajax'])) {
      return $this->get_option('use_ajax');
    }
    return FALSE;
  }

views_plugin_display::use_group_by ( ) [inherited]

Does the display have groupby enabled?

Definition at line 338 of file views_plugin_display.inc.

References views_plugin_display::get_option().

Referenced by views_plugin_display::export_handler(), and views_plugin_display::get_handlers().

                          {
    return $this->get_option('group_by');
  }

views_plugin_display::use_more ( ) [inherited]

Does the display have a more link enabled?

Definition at line 328 of file views_plugin_display.inc.

References views_plugin_display::get_option().

Referenced by views_plugin_display::pre_execute(), and views_plugin_display::render_more_link().

                      {
    if (!empty($this->definition['use more'])) {
      return $this->get_option('use_more');
    }
    return FALSE;
  }

views_plugin_display::use_more_always ( ) [inherited]

Should the enabled display more link be shown when no more items?

Definition at line 345 of file views_plugin_display.inc.

References views_plugin_display::get_option().

Referenced by views_plugin_display::pre_execute(), and views_plugin_display::render_more_link().

                             {
    if (!empty($this->definition['use more'])) {
      return $this->get_option('use_more_always');
    }
    return FALSE;
  }

views_plugin_display::use_more_text ( ) [inherited]

Does the display have custom link text?

Definition at line 355 of file views_plugin_display.inc.

References views_plugin_display::get_option().

Referenced by views_plugin_display::render_more_link().

                           {
    if (!empty($this->definition['use more'])) {
      return $this->get_option('use_more_text');
    }
    return FALSE;
  }

views_plugin_display::use_pager ( ) [inherited]

Does the display have a pager enabled?

Reimplemented in views_plugin_display_attachment.

Definition at line 318 of file views_plugin_display.inc.

References views_plugin_display::get_plugin().

                       {
    $pager = $this->get_plugin('pager');
    if ($pager) {
      return $pager->use_pager();
    }
  }

views_plugin_display::uses_breadcrumb ( ) [inherited]

Check to see if the display needs a breadcrumb.

By default, displays do not need breadcrumbs

Reimplemented in views_plugin_display_feed, and views_plugin_display_page.

Definition at line 767 of file views_plugin_display.inc.

{ return FALSE; }

views_plugin_display_block::uses_exposed ( )

Block views use exposed widgets only if AJAX is set.

Reimplemented from views_plugin_display.

Definition at line 182 of file views_plugin_display_block.inc.

References views_plugin_display::use_ajax().

                          {
    if ($this->use_ajax()) {
      return parent::uses_exposed();
    }

    return FALSE;
  }

views_plugin_display::uses_exposed_form_in_block ( ) [inherited]

Check to see if the display can put the exposed formin a block.

By default, displays that do not have a path cannot disconnect the exposed form and put it in a block, because the form has no place to go and Views really wants the forms to go to a specific page.

Definition at line 723 of file views_plugin_display.inc.

References views_plugin_display::has_path().

Referenced by views_plugin_display::get_special_blocks(), and views_plugin_display::options_summary().

{ return $this->has_path(); }

views_plugin_display::uses_fields ( ) [inherited]

Determine if the display's style uses fields.

Definition at line 797 of file views_plugin_display.inc.

References views_plugin_display::get_plugin().

Referenced by views_plugin_display::validate().

                         {
    $plugin = $this->get_plugin();
    if ($plugin) {
      return $plugin->uses_fields();
    }
  }

views_plugin_display::uses_link_display ( ) [inherited]

Check to see if the display has some need to link to another display.

For the most part, displays without a path will use a link display. However, sometimes displays that have a path might also need to link to another display. This is true for feeds.

Reimplemented in views_plugin_display_feed.

Definition at line 713 of file views_plugin_display.inc.

References views_plugin_display::has_path().

Referenced by views_plugin_display::options_summary().

{ return !$this->has_path(); }

views_plugin_display::validate ( ) [inherited]

Make sure the display and all associated handlers are valid.

Returns:: Empty array if the display is valid; an array of error strings if it is not.

Reimplemented from views_plugin.

Reimplemented in views_plugin_display_page.

Definition at line 2615 of file views_plugin_display.inc.

References views_plugin_display::get_handlers(), views_plugin_display::get_option(), views_plugin_display::get_plugin(), views_plugin_display::has_path(), views_plugin_display::uses_fields(), and views_object_types().

                      {
    $errors = array();
    // Make sure displays that use fields HAVE fields.
    if ($this->uses_fields()) {
      $fields = FALSE;
      foreach ($this->get_handlers('field') as $field) {
        if (empty($field->options['exclude'])) {
          $fields = TRUE;
        }
      }

      if (!$fields) {
        $errors[] = t('Display "@display" uses fields but there are none defined for it or all are excluded.', array('@display' => $this->display->display_title));
      }
    }

    if ($this->has_path() && !$this->get_option('path')) {
      $errors[] = t('Display "@display" uses a path but the path is undefined.', array('@display' => $this->display->display_title));
    }

    // Validate style plugin
    $style = $this->get_plugin();
    if (empty($style)) {
      $errors[] = t('Display "@display" has an invalid style plugin.', array('@display' => $this->display->display_title));
    }
    else {
      $result = $style->validate();
      if (!empty($result) && is_array($result)) {
        $errors = array_merge($errors, $result);
      }
    }

    // Validate query plugin.
    $query = $this->get_plugin('query');
    $result = $query->validate();
    if (!empty($result) && is_array($result)) {
      $errors = array_merge($errors, $result);
    }

    // Validate handlers
    foreach (views_object_types() as $type => $info) {
      foreach ($this->get_handlers($type) as $handler) {
        $result = $handler->validate();
        if (!empty($result) && is_array($result)) {
          $errors = array_merge($errors, $result);
        }
      }
    }

    return $errors;
  }

views_plugin_display::view_special_blocks ( $ type ) [inherited]

Render any special blocks provided for this display.

Definition at line 2705 of file views_plugin_display.inc.

References views_plugin_display::get_option(), views_plugin_display::get_plugin(), and views_plugin_display::uses_exposed().

                                      {
    if ($type == '-exp') {
      // avoid interfering with the admin forms.
      if (arg(0) == 'admin' && arg(1) == 'structure' && arg(2) == 'views') {
        return;
      }
      $this->view->init_handlers();

      if ($this->uses_exposed() && $this->get_option('exposed_block')) {
        $exposed_form = $this->get_plugin('exposed_form');
        return array(
          'content' => $exposed_form->render_exposed_form(TRUE),
        );
      }
    }
  }