Plugin which performs a node_view on the resulting object. More...

Inheritance diagram for views_plugin_row_node_view:

Public Member Functions
	init (&$view, &$display, $options=NULL)
	Initialize the row plugin.
	option_definition ()
	Information about options for all kinds of purposes will be held here.
	options_form (&$form, &$form_state)
	Provide a form for setting options.
	options_form_summary_options ()
	Return the main options, which are shown in the summary title.
	summary_title ()
	Returns the summary of the settings in the display.
	pre_render ($values)
	Allow the style to do stuff before each row is rendered.
	render ($row)
	Render a row object.
	uses_fields ()
	options_validate (&$form, &$form_state)
	Validate the options form.
	options_submit (&$form, &$form_state)
	Perform any necessary changes to the form values prior to storage.
	query ()
	Add anything to the query that we might need to.
	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.
	validate ()
	Validate that the plugin is correct and can be saved.
	plugin_title ()
	Return the human readable name of the display.
	construct ()
	Views handlers use a special construct function so that we can more easily construct them with variable arguments.
	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.
	destroy ()
	export_options ($indent, $prefix)
	export_option ($indent, $prefix, $storage, $option, $definition, $parents)
	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
	$base_table = 'node'
	$base_field = 'nid'
	$nodes = array()
	$view = NULL
	$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

Plugin which performs a node_view on the resulting object.

Most of the code on this object is in the theme function.

Definition at line 14 of file views_plugin_row_node_view.inc.

Member Function Documentation

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_object::construct ( ) [inherited]

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

Definition at line 54 of file base.inc.

References views_object::set_default_options().

{ $this->set_default_options(); }

views_plugin_row_node_view::init	(	&$	view,
		&$	display,
		$	options = `NULL`
	)

Initialize the row plugin.

Reimplemented from views_plugin_row.

Definition at line 22 of file views_plugin_row_node_view.inc.

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

                                                    {
    parent::init($view, $display, $options);
    // Handle existing views with the deprecated 'teaser' option.
    if (isset($this->options['teaser'])) {
      $this->options['build_mode'] = $this->options['teaser'] ? 'teaser' : 'full';
    }
    // Handle existing views which has used build_mode instead of view_mode.
    if (isset($this->options['build_mode'])) {
      $this->options['view_mode'] = $this->options['build_mode'];
    }
  }

views_plugin_row_node_view::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_row.

Definition at line 34 of file views_plugin_row_node_view.inc.

References views_object::$options.

                               {
    $options = parent::option_definition();

    $options['view_mode'] = array('default' => 'teaser');
    $options['links'] = array('default' => TRUE);
    $options['comments'] = array('default' => FALSE);

    return $options;
  }

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_row_node_view::options_form	(	&$	form,
		&$	form_state
	)

Provide a form for setting options.

Reimplemented from views_plugin_row.

Definition at line 44 of file views_plugin_row_node_view.inc.

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

                                              {
    parent::options_form($form, $form_state);

    $options = $this->options_form_summary_options();
    $form['view_mode'] = array(
      '#type' => 'select',
      '#options' => $options,
      '#title' => t('View mode'),
      '#default_value' => $this->options['view_mode'],
     );
    $form['links'] = array(
      '#type' => 'checkbox',
      '#title' => t('Display links'),
      '#default_value' => $this->options['links'],
    );
    $form['comments'] = array(
      '#type' => 'checkbox',
      '#title' => t('Display comments'),
      '#default_value' => $this->options['comments'],
    );
  }

views_plugin_row_node_view::options_form_summary_options ( )

Return the main options, which are shown in the summary title.

Definition at line 69 of file views_plugin_row_node_view.inc.

References views_object::$options.

Referenced by options_form(), and summary_title().

                                          {
    $entity_info = entity_get_info('node');
    $options = array();
    if (!empty($entity_info['view modes'])) {
      foreach ($entity_info['view modes'] as $mode => $settings) {
        $options[$mode] = $settings['label'];
      }
    }
    if (empty($options)) {
      $options = array(
        'teaser' => t('Teaser'),
        'full' => t('Full content')
      );
    }

    return $options;
  }

views_plugin_row::options_submit	(	&$	form,
		&$	form_state
	)			`[inherited]`

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.

Reimplemented in views_plugin_row_fields.

Definition at line 108 of file views_plugin_row.inc.

{ }

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

Validate the options form.

Reimplemented from views_plugin.

Definition at line 102 of file views_plugin_row.inc.

{ }

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_row_node_view::pre_render ( $ result )

Allow the style to do stuff before each row is rendered.

Parameters:

$result

The full array of results from the query.

Reimplemented from views_plugin_row.

Definition at line 92 of file views_plugin_row_node_view.inc.

                               {
    $nids = array();
    foreach ($values as $row) {
      $nids[] = $row->{$this->field_alias};
    }
    $this->nodes = node_load_multiple($nids);
  }

views_plugin_row::query ( ) [inherited]

Add anything to the query that we might need to.

Reimplemented from views_plugin.

Definition at line 110 of file views_plugin_row.inc.

References views_object::options().

                   {
    if (isset($this->base_table)) {
      if (isset($this->options['relationship']) && isset($this->view->relationship[$this->options['relationship']])) {
        $relationship = $this->view->relationship[$this->options['relationship']];
        $this->field_alias = $this->view->query->add_field($relationship->alias, $this->base_field);
      }
      else {
        $this->field_alias = $this->view->query->add_field($this->base_table, $this->base_field);
      }
    }
  }

views_plugin_row_node_view::render ( $ row )

Render a row object.

This usually passes through to a theme template of some form, but not always.

Reimplemented from views_plugin_row.

Definition at line 100 of file views_plugin_row_node_view.inc.

                        {
    $node = $this->nodes[$row->{$this->field_alias}];
    $node->view = $this->view;
    $build = node_view($node, $this->options['view_mode']);

    return drupal_render($build);
  }

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_row_node_view::summary_title ( )

Returns the summary of the settings in the display.

Reimplemented from views_plugin.

Definition at line 87 of file views_plugin_row_node_view.inc.

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

                           {
    $options = $this->options_form_summary_options();
    return check_plain($options[$this->options['view_mode']]);
  }

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_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_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::validate ( ) [inherited]

Validate that the plugin is correct and can be saved.