Style plugin to render each item as a row in a table. More...

Inheritance diagram for views_plugin_style_jump_menu:

Public Member Functions
	option_definition ()
	Information about options for all kinds of purposes will be held here.
	options_form (&$form, &$form_state)
	Render the given style.
	render ()
	Render the display in this style.
	render_set ($title, $records)
	init (&$view, &$display, $options=NULL)
	Initialize a style plugin.
	destroy ()
	uses_row_plugin ()
	Return TRUE if this style also uses a row plugin.
	uses_row_class ()
	Return TRUE if this style also uses a row plugin.
	uses_fields ()
	Return TRUE if this style also uses fields.
	uses_tokens ()
	Return TRUE if this style uses tokens.
	get_row_class ($row_index)
	Return the token replaced row class for the specified row.
	tokenize_value ($value, $row_index)
	Take a value and apply token replacement logic to it.
	even_empty ()
	Should the output of the style plugin be rendered even if it's a empty view.
	options_validate (&$form, &$form_state)
	Validate the options form.
	build_sort ()
	Called by the view builder to see if this style handler wants to interfere with the sorts.
	build_sort_post ()
	Called by the view builder to let the style build a second set of sorts that will come after any other sorts in the view.
	pre_render ($result)
	Allow the style to do stuff before each row is rendered.
	render_grouping_sets ($sets, $level=0)
	Render the grouping sets.
	render_grouping ($records, $groupings=array(), $group_rendered=NULL)
	Group records as needed for rendering.
	render_fields ($result)
	Render all of the fields for a given style and store them on the object.
	get_field ($index, $field)
	Get a rendered field.
	get_field_value ($index, $field)
	Get the raw field value.
	validate ()
	Validate that the plugin is correct and can be saved.
	query ()
	Add anything to the query that we might need to.
	options_submit (&$form, &$form_state)
	Handle any special handling on the validate form.
	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.
	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.
	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
	$row_tokens = array()
	Store all available tokens row rows.
	$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

Style plugin to render each item as a row in a table.

Definition at line 12 of file views_plugin_style_jump_menu.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_plugin_style::build_sort ( ) [inherited]

Called by the view builder to see if this style handler wants to interfere with the sorts.

If so it should build; if it returns any non-TRUE value, normal sorting will NOT be added to the query.

Reimplemented in views_plugin_style_table.

Definition at line 250 of file views_plugin_style.inc.

{ return TRUE; }

views_plugin_style::build_sort_post ( ) [inherited]

Called by the view builder to let the style build a second set of sorts that will come after any other sorts in the view.

Reimplemented in views_plugin_style_table.

Definition at line 256 of file views_plugin_style.inc.

{ }

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_style::even_empty ( ) [inherited]

Should the output of the style plugin be rendered even if it's a empty view.

Reimplemented in views_plugin_style_table.

Definition at line 148 of file views_plugin_style.inc.

                        {
    return !empty($this->definition['even empty']);
  }

views_plugin_style::get_field	(	$	index,
		$	field
	)			`[inherited]`

Get a rendered field.

Parameters:

	$index	The index count of the row.
	$field	The id of the field.

Definition at line 504 of file views_plugin_style.inc.

References views_plugin_style::render_fields().

Referenced by render(), and views_plugin_style::render_grouping().

                                     {
    if (!isset($this->rendered_fields)) {
      $this->render_fields($this->view->result);
    }

    if (isset($this->rendered_fields[$index][$field])) {
      return $this->rendered_fields[$index][$field];
    }
  }

views_plugin_style::get_field_value	(	$	index,
		$	field
	)			`[inherited]`

Get the raw field value.

Parameters:

	$index	The index count of the row.
	$field	The id of the field.

Definition at line 522 of file views_plugin_style.inc.

Referenced by views_plugin_style::render_grouping().

                                           {
    $this->view->row_index = $index;
    $value = $this->view->field[$field]->get_value($this->view->result[$index]);
    unset($this->view->row_index);
    return $value;
  }

views_plugin_style::get_row_class ( $ row_index ) [inherited]

Return the token replaced row class for the specified row.

Definition at line 106 of file views_plugin_style.inc.

References views_object::options(), views_plugin_style::tokenize_value(), views_plugin_style::uses_fields(), and views_plugin_style::uses_row_class().

                                     {
    if ($this->uses_row_class()) {
      $class = $this->options['row_class'];
      if ($this->uses_fields() && $this->view->field) {
        $class = strip_tags($this->tokenize_value($class, $row_index));
      }

      $classes = explode(' ', $class);
      foreach ($classes as &$class) {
        $class = drupal_clean_css_identifier($class);
      }
      return implode(' ', $classes);
    }
  }

views_plugin_style::init	(	&$	view,
		&$	display,
		$	options = `NULL`
	)			`[inherited]`

Initialize a style plugin.

Parameters:

	$view
	$display
	$options	The style options might come externally as the style can be sourced from at least two locations. If it's not included, look on the display.

Definition at line 34 of file views_plugin_style.inc.

References views_object::$options, views_object::options(), views_object::unpack_options(), and views_plugin_style::uses_row_plugin().

                                                    {
    $this->view = &$view;
    $this->display = &$display;

    // Overlay incoming options on top of defaults
    $this->unpack_options($this->options, isset($options) ? $options : $display->handler->get_option('style_options'));

    if ($this->uses_row_plugin() && $display->handler->get_option('row_plugin')) {
      $this->row_plugin = $display->handler->get_plugin('row');
    }

    $this->options += array(
      'grouping' => array(),
    );

    $this->definition += array(
      'uses grouping' => TRUE,
    );
  }

views_plugin_style_jump_menu::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_style.

Definition at line 13 of file views_plugin_style_jump_menu.inc.

References views_object::$options.

                               {
    $options = parent::option_definition();

    $options['hide'] = array('default' => FALSE);
    $options['path'] = array('default' => '');
    $options['text'] = array('default' => 'Go', 'translatable' => TRUE);
    $options['choose'] = array('default' => '- Choose -', 'translatable' => TRUE);
    $options['default_value'] = 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_style_jump_menu::options_form	(	&$	form,
		&$	form_state
	)

Render the given style.

Reimplemented from views_plugin_style.

Definition at line 28 of file views_plugin_style_jump_menu.inc.

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

                                              {
    parent::options_form($form, $form_state);
    $handlers = $this->display->handler->get_handlers('field');
    if (empty($handlers)) {
      $form['error_markup'] = array(
        '#markup' => t('You need at least one field before you can configure your jump menu settings'),
        '#prefix' => '<div class="error messages">',
        '#suffix' => '</div>',
      );
      return;
    }

    $form['markup'] = array(
      '#markup' => t('To properly configure a jump menu, you must select one field that will represent the path to utilize. You should then set that field to exclude. All other displayed fields will be part of the menu. Please note that all HTML will be stripped from this output as select boxes cannot show HTML.'),
      '#prefix' => '<div class="form-item description">',
      '#suffix' => '</div>',
    );

    foreach ($handlers as $id => $handler) {
      $options[$id] = $handler->ui_name();
    }

    $form['path'] = array(
      '#type' => 'select',
      '#title' => t('Path field'),
      '#options' => $options,
      '#default_value' => $this->options['path'],
    );

    $form['hide'] = array(
      '#type' => 'checkbox',
      '#title' => t('Hide the "Go" button'),
      '#default_value' => !empty($this->options['hide']),
      '#description' => t('If hidden, this button will only be hidden for users with javascript and the page will automatically jump when the select is changed.'),
    );

    $form['text'] = array(
      '#type' => 'textfield',
      '#title' => t('Button text'),
      '#default_value' => $this->options['text'],
    );

    $form['choose'] = array(
      '#type' => 'textfield',
      '#title' => t('Choose text'),
      '#default_value' => $this->options['choose'],
      '#description' => t('The text that will appear as the selected option in the jump menu.'),
    );

    $form['default_value'] = array(
      '#type' => 'checkbox',
      '#title' => t('Select the current contextual filter value'),
      '#default_value' => !empty($this->options['default_value']),
      '#description' => t('If checked, the current path will be displayed as the default option in the jump menu, if applicable.'),
    );
  }

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

Handle any special handling on the validate form.

Reimplemented in views_plugin_access, views_plugin_access_role, views_plugin_display, views_plugin_display_attachment, views_plugin_display_block, views_plugin_display_extender, views_plugin_display_feed, views_plugin_display_page, views_plugin_exposed_form_input_required, views_plugin_pager, views_plugin_query, views_plugin_row, and views_plugin_row_fields.

Definition at line 501 of file plugins.inc.

{ }

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

Validate the options form.

Reimplemented from views_plugin.

Definition at line 233 of file views_plugin_style.inc.

                                                  {
    // Don't run validation on style plugins without the grouping setting.
    if (isset($form_state['values']['style_options']['grouping'])) {
      // Don't save grouping if no field is specified.
      foreach ($form_state['values']['style_options']['grouping'] as $index => $grouping) {
        if (empty($grouping['field'])) {
          unset($form_state['values']['style_options']['grouping'][$index]);
        }
      }
    }
  }

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_style::pre_render ( $ result ) [inherited]

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

Parameters:

$result

The full array of results from the query.

Definition at line 264 of file views_plugin_style.inc.

                               {
    if (!empty($this->row_plugin)) {
      $this->row_plugin->pre_render($result);
    }
  }

views_plugin_style::query ( ) [inherited]

Add anything to the query that we might need to.

Reimplemented from views_plugin.

Reimplemented in views_plugin_style_summary, and views_plugin_style_summary_jump_menu.

Definition at line 547 of file views_plugin_style.inc.

                   {
    parent::query();
    if (isset($this->row_plugin)) {
      $this->row_plugin->query();
    }
  }

views_plugin_style_jump_menu::render ( )

Render the display in this style.

This is overridden so that we can render our grouping specially.

Reimplemented from views_plugin_style.

Definition at line 90 of file views_plugin_style_jump_menu.inc.

References views_object::$options, views_plugin_style::get_field(), views_object::options(), and views_plugin_style::render_grouping().

                    {
    $sets = $this->render_grouping($this->view->result, $this->options['grouping']);

    // Turn this all into an $options array for the jump menu.
    $this->view->row_index = 0;
    $options = array();
    $paths = array();

    foreach ($sets as $title => $records) {
      foreach ($records as $row_index => $row) {
        $this->view->row_index = $row_index;
        $path = strip_tags(decode_entities($this->get_field($this->view->row_index, $this->options['path'])));
        // Putting a '/' in front messes up url() so let's take that out
        // so users don't shoot themselves in the foot.
        $base_path = base_path();
        if (strpos($path, $base_path) === 0) {
          $path = drupal_substr($path, drupal_strlen($base_path));
        }

        // use drupal_parse_url() to preserve query and fragment in case the user
        // wants to do fun tricks.
        $url_options = drupal_parse_url($path);

        $path = url($url_options['path'], $url_options);
        $field = strip_tags(decode_entities($this->row_plugin->render($row)));
        $key = md5($path . $field) . "::" . $path;
        if ($title) {
          $options[$title][$key] = $field;
        }
        else {
          $options[$key] = $field;
        }
        $paths[$path] = $key;
        $this->view->row_index++;
      }
    }
    unset($this->view->row_index);

    $default_value = '';
    if ($this->options['default_value'] && !empty($paths[url($_GET['q'])])) {
      $default_value = $paths[url($_GET['q'])];
    }

    ctools_include('jump-menu');
    $settings = array(
      'hide' => $this->options['hide'],
      'button' => $this->options['text'],
      'choose' => $this->options['choose'],
      'default_value' => $default_value,
    );

    $form = drupal_get_form('ctools_jump_menu', $options, $settings);
    return $form;
  }

views_plugin_style::render_fields ( $ result ) [inherited]

Render all of the fields for a given style and store them on the object.

Parameters:

$result

The result array from $view->result

Definition at line 468 of file views_plugin_style.inc.

References views_plugin_style::uses_fields().

Referenced by views_plugin_style::get_field(), and views_plugin_style::render_grouping().

                                  {
    if (!$this->uses_fields()) {
      return;
    }

    if (!isset($this->rendered_fields)) {
      $this->rendered_fields = array();
      $this->view->row_index = 0;
      $keys = array_keys($this->view->field);

      // If all fields have a field::access FALSE there might be no fields, so
      // there is no reason to execute this code.
      if (!empty($keys)) {
        foreach ($result as $count => $row) {
          $this->view->row_index = $count;
          foreach ($keys as $id) {
            $this->rendered_fields[$count][$id] = $this->view->field[$id]->theme($row);
          }

          $this->row_tokens[$count] = $this->view->field[$id]->get_render_tokens(array());
        }
      }
      unset($this->view->row_index);
    }

    return $this->rendered_fields;
  }

views_plugin_style::render_grouping	(	$	records,
		$	groupings = `array()`,
		$	group_rendered = `NULL`
	)			`[inherited]`

Group records as needed for rendering.

Parameters:

	$records	An array of records from the view to group.
	$groupings	An array of grouping instructions on which fields to group. If empty, the result set will be given a single group with an empty string as a label.
	$group_rendered	Boolean value whether to use the rendered or the raw field value for grouping. If set to NULL the return is structured as before Views 7.x-3.0-rc2. After Views 7.x-3.0 this boolean is only used if $groupings is an old-style string or if the rendered option is missing for a grouping instruction.

Returns:: The grouped record set. A nested set structure is generated if multiple grouping fields are used.

   array(
     'grouping_field_1:grouping_1' => array(
       'group' => 'grouping_field_1:content_1',
       'rows' => array(
         'grouping_field_2:grouping_a' => array(
           'group' => 'grouping_field_2:content_a',
           'rows' => array(
             $row_index_1 => $row_1,
             $row_index_2 => $row_2,
             // ...
           )
         ),
       ),
     ),
     'grouping_field_1:grouping_2' => array(
       // ...
     ),
   )

Definition at line 380 of file views_plugin_style.inc.

References views_plugin_style::get_field(), views_plugin_style::get_field_value(), and views_plugin_style::render_fields().

Referenced by render(), and views_plugin_style::render().

                                                                                   {
    // This is for backward compability, when $groupings was a string containing
    // the ID of a single field.
    if (is_string($groupings)) {
      $rendered = $group_rendered === NULL ? TRUE : $group_rendered;
      $groupings = array(array('field' => $groupings, 'rendered' => $rendered));
    }

    // Make sure fields are rendered
    $this->render_fields($this->view->result);
    $sets = array();
    if ($groupings) {
      foreach ($records as $index => $row) {
        // Iterate through configured grouping fields to determine the
        // hierarchically positioned set where the current row belongs to.
        // While iterating, parent groups, that do not exist yet, are added.
        $set = &$sets;
        foreach ($groupings as $info) {
          $field = $info['field'];
          $rendered = isset($info['rendered']) ? $info['rendered'] : $group_rendered;
          $rendered_strip = isset($info['rendered_strip']) ? $info['rendered_strip'] : FALSE;
          $grouping = '';
          $group_content = '';
          // Group on the rendered version of the field, not the raw.  That way,
          // we can control any special formatting of the grouping field through
          // the admin or theme layer or anywhere else we'd like.
          if (isset($this->view->field[$field])) {
            $group_content = $this->get_field($index, $field);
            if ($this->view->field[$field]->options['label']) {
              $group_content = $this->view->field[$field]->options['label'] . ': ' . $group_content;
            }
            if ($rendered) {
              $grouping = $group_content;
              if ($rendered_strip) {
                $group_content = $grouping = strip_tags(htmlspecialchars_decode($group_content));
              }
            }
            else {
              $grouping = $this->get_field_value($index, $field);
              // Not all field handlers return a scalar value,
              // e.g. views_handler_field_field.
              if (!is_scalar($grouping)) {
                $grouping = md5(serialize($grouping));
              }
            }
          }

          // Create the group if it does not exist yet.
          if (empty($set[$grouping])) {
            $set[$grouping]['group'] = $group_content;
            $set[$grouping]['rows'] = array();
          }

          // Move the set reference into the row set of the group we just determined.
          $set = &$set[$grouping]['rows'];
        }
        // Add the row to the hierarchically positioned row set we just determined.
        $set[$index] = $row;
      }
    }
    else {
      // Create a single group with an empty grouping field.
      $sets[''] = array(
        'group' => '',
        'rows' => $records,
      );
    }

    // If this parameter isn't explicitely set modify the output to be fully
    // backward compatible to code before Views 7.x-3.0-rc2.
    // @TODO Remove this as soon as possible e.g. October 2020
    if ($group_rendered === NULL) {
      $old_style_sets = array();
      foreach ($sets as $group) {
        $old_style_sets[$group['group']] = $group['rows'];
      }
      $sets = $old_style_sets;
    }

    return $sets;
  }

views_plugin_style::render_grouping_sets	(	$	sets,
		$	level = `0`
	)			`[inherited]`

Render the grouping sets.

Plugins may override this method if they wish some other way of handling grouping.

Parameters:

	$sets	Array containing the grouping sets to render.
	$level	Integer indicating the hierarchical level of the grouping.

Returns:: string Rendered output of given grouping sets.

Definition at line 303 of file views_plugin_style.inc.

References views_object::options(), views_plugin::theme_functions(), views_plugin_style::uses_row_plugin(), and views_theme_functions().

Referenced by views_plugin_style::render().

                                                   {
    $output = '';
    foreach ($sets as $set) {
      $row = reset($set['rows']);
      // Render as a grouping set.
      if (is_array($row) && isset($row['group'])) {
        $output .= theme(views_theme_functions('views_view_grouping', $this->view, $this->display),
          array(
            'view' => $this->view,
            'grouping' => $this->options['grouping'][$level],
            'grouping_level' => $level,
            'rows' => $set['rows'],
            'title' => $set['group'])
        );
      }
      // Render as a record set.
      else {
        if ($this->uses_row_plugin()) {
          foreach ($set['rows'] as $index => $row) {
            $this->view->row_index = $index;
            $set['rows'][$index] = $this->row_plugin->render($row);
          }
        }

        $output .= theme($this->theme_functions(),
          array(
            'view' => $this->view,
            'options' => $this->options,
            'grouping_level' => $level,
            'rows' => $set['rows'],
            'title' => $set['group'])
        );
      }
    }
    unset($this->view->row_index);
    return $output;
  }

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::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_style::tokenize_value	(	$	value,
		$	row_index
	)			`[inherited]`

Take a value and apply token replacement logic to it.

Definition at line 124 of file views_plugin_style.inc.

Referenced by views_plugin_style::get_row_class().

                                              {
    if (strpos($value, '[') !== FALSE || strpos($value, '!') !== FALSE || strpos($value, '%') !== FALSE) {
      $fake_item = array(
        'alter_text' => TRUE,
        'text' => $value,
      );

      // Row tokens might be empty, for example for node row style.
      $tokens = isset($this->row_tokens[$row_index]) ? $this->row_tokens[$row_index] : array();
      if (!empty($this->view->build_info['substitutions'])) {
        $tokens += $this->view->build_info['substitutions'];
      }

      if ($tokens) {
        $value = strtr($value, $tokens);
      }
    }

    return $value;
  }

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_style::uses_fields ( ) [inherited]

Return TRUE if this style also uses fields.

Definition at line 79 of file views_plugin_style.inc.

References views_plugin_style::uses_row_plugin().

Referenced by views_plugin_style::get_row_class(), views_plugin_style::options_form(), and views_plugin_style::render_fields().

                         {
    // If we use a row plugin, ask the row plugin. Chances are, we don't
    // care, it does.
    if ($this->uses_row_plugin() && !empty($this->row_plugin)) {
      return $this->row_plugin->uses_fields();
    }
    // Otherwise, maybe we do.
    return !empty($this->definition['uses fields']);
  }

views_plugin_style::uses_row_class ( ) [inherited]

Return TRUE if this style also uses a row plugin.

Definition at line 72 of file views_plugin_style.inc.

Referenced by views_plugin_style::get_row_class(), views_plugin_style::option_definition(), views_plugin_style::options_form(), and views_plugin_style::uses_tokens().

                            {
    return !empty($this->definition['uses row class']);
  }

views_plugin_style::uses_row_plugin ( ) [inherited]

Return TRUE if this style also uses a row plugin.

Definition at line 65 of file views_plugin_style.inc.

Referenced by views_plugin_style::init(), views_plugin_style::render(), views_plugin_style::render_grouping_sets(), views_plugin_style::uses_fields(), and views_plugin_style::validate().

                             {
    return !empty($this->definition['uses row plugin']);
  }

views_plugin_style::uses_tokens ( ) [inherited]

Return TRUE if this style uses tokens.

Used to ensure we don't fetch tokens when not needed for performance.

Definition at line 94 of file views_plugin_style.inc.

References views_object::options(), and views_plugin_style::uses_row_class().

                         {
    if ($this->uses_row_class()) {
      $class = $this->options['row_class'];
      if (strpos($class, '[') !== FALSE || strpos($class, '!') !== FALSE || strpos($class, '%') !== FALSE) {
        return TRUE;
      }
    }
  }

views_plugin_style::validate ( ) [inherited]

Validate that the plugin is correct and can be saved.

Returns:: An array of error strings to tell the user what is wrong with this plugin.

Reimplemented from views_plugin.

Definition at line 529 of file views_plugin_style.inc.

References views_plugin_style::uses_row_plugin().

                      {
    $errors = parent::validate();

    if ($this->uses_row_plugin()) {
      $plugin = $this->display->handler->get_plugin('row');
      if (empty($plugin)) {
        $errors[] = t('Style @style requires a row style but the row plugin is invalid.', array('@style' => $this->definition['title']));
      }
      else {
        $result = $plugin->validate();
        if (!empty($result) && is_array($result)) {
          $errors = array_merge($errors, $result);
        }
      }
    }
    return $errors;
  }

Member Data Documentation

views_object::$options = array() [inherited]

Except for displays, options for the object will be held here.

Definition at line 15 of file base.inc.

views_plugin::$plugin_type = NULL [inherited]

The plugin type of this plugin, for example style or query.

Definition at line 475 of file plugins.inc.

Referenced by views_plugin_display::export_plugin(), and views_plugin_display::unpack_plugin().

views_plugin_style::$row_tokens = array() [inherited]

Store all available tokens row rows.

Definition at line 24 of file views_plugin_style.inc.

The documentation for this class was generated from the following file:

plugins/views_plugin_style_jump_menu.inc

views_plugin_style_jump_menu Class Reference [Views' style plugins]

Public Member Functions

Public Attributes

Detailed Description

Member Function Documentation

Member Data Documentation

views_plugin_style_jump_menu Class Reference
[Views' style plugins]