Handles relationships for content translation sets and provides multiple options. More...

Inheritance diagram for views_handler_relationship_translation:

Public Member Functions
	option_definition ()
	Information about options for all kinds of purposes will be held here.
	options_form (&$form, &$form_state)
	Add a translation selector.
	query ()
	Called to implement a relationship in a query.
	init (&$view, &$options)
	Init handler to let relationships live on tables other than the table they operate on.
	label ()
	Get this field's label.
	use_group_by ()
	You can't groupby a relationship.
	ui_name ($short=FALSE)
	Return a string representing this handler's name in the UI.
	get_field ($field=NULL)
	Shortcut to get a handler's raw field value.
	sanitize_value ($value, $type=NULL)
	Sanitize the value for output.
	case_transform ($string, $option)
	Transform a string by a certain method.
	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.
	groupby_form (&$form, &$form_state)
	Provide a form for aggregation settings.
	groupby_form_submit (&$form, &$form_state)
	Perform any necessary changes to the form values prior to storage.
	has_extra_options ()
	If a handler has 'extra options' it will get a little settings widget and another form called extra_options.
	extra_options (&$option)
	Provide defaults for the handler.
	extra_options_form (&$form, &$form_state)
	Provide a form for setting options.
	extra_options_validate ($form, &$form_state)
	Validate the options form.
	extra_options_submit ($form, &$form_state)
	Perform any necessary changes to the form values prior to storage.
	can_expose ()
	Determine if a handler can be exposed.
	expose_options ()
	Set new exposed option defaults when exposed setting is flipped on.
	exposed_info ()
	Get information about the exposed form for the form renderer.
	exposed_form (&$form, &$form_state)
	Render our chunk of the exposed handler form when selecting.
	exposed_validate (&$form, &$form_state)
	Validate the exposed handler form.
	exposed_submit (&$form, &$form_state)
	Submit the exposed handler form.
	expose_form (&$form, &$form_state)
	Form for exposed handler options.
	expose_validate ($form, &$form_state)
	Validate the options form.
	expose_submit ($form, &$form_state)
	Perform any necessary changes to the form exposes prior to storage.
	show_expose_button (&$form, &$form_state)
	Shortcut to display the expose/hide button.
	show_expose_form (&$form, &$form_state)
	Shortcut to display the exposed options form.
	access ()
	Check whether current user has access to this handler.
	pre_query ()
	Run before the view is built.
	post_execute (&$values)
	Run after the view is executed, before the result is cached.
	placeholder ()
	Provides a unique placeholders for handlers.
	set_relationship ()
	Called just prior to query(), this lets a handler set up any relationship it needs.
	ensure_my_table ()
	Ensure the main table for this handler is in the query.
	admin_summary ()
	Provide text for the administrative summary.
	needs_style_plugin ()
	Determine if the argument needs a style plugin.
	is_exposed ()
	Determine if this item is 'exposed', meaning it provides form elements to let users modify the view.
	accept_exposed_input ($input)
	Take input from exposed handlers and assign to this handler, if necessary.
	store_exposed_input ($input, $status)
	If set to remember exposed input in the session, store it there.
	get_join ()
	Get the join object that should be used for this handler.
	validate ()
	Validates the handler against the complete View.
	broken ()
	Determine if the handler is considered 'broken', meaning it's a a placeholder used when a handler can't be found.
	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
	$view = NULL
	$query = NULL
	$handler_type = NULL
	The type of the handler, for example filter/footer/field.
	$table_alias
	The alias of the table of this handler which is used in the query.
	$real_field
	The actual field in the database table, maybe different on other kind of query plugins/special handlers.
	$relationship = NULL
	The relationship used for this field.
	$options = array()
	Except for displays, options for the object will be held here.
	$definition

Detailed Description

Handles relationships for content translation sets and provides multiple options.

Definition at line 9 of file views_handler_relationship_translation.inc.

Member Function Documentation

views_handler::accept_exposed_input ( $ input ) [inherited]

Take input from exposed handlers and assign to this handler, if necessary.

Reimplemented in views_handler_filter, views_handler_filter_date, views_handler_filter_in_operator, views_handler_filter_numeric, views_handler_filter_term_node_tid, and views_handler_filter_user_name.

Definition at line 669 of file handlers.inc.

{ return TRUE; }

views_handler::access ( ) [inherited]

Check whether current user has access to this handler.

Returns:: boolean

Reimplemented in views_handler_field_comment_link_approve, views_handler_field_comment_link_delete, views_handler_field_comment_link_reply, views_handler_field_contact_link, views_handler_field_field, views_handler_field_locale_link_edit, views_handler_field_node_revision_link_delete, views_handler_field_node_revision_link_revert, and views_handler_field_user_link.

Definition at line 564 of file handlers.inc.

                    {
    if (isset($this->definition['access callback']) && function_exists($this->definition['access callback'])) {
      if (isset($this->definition['access arguments']) && is_array($this->definition['access arguments'])) {
        return call_user_func_array($this->definition['access callback'], $this->definition['access arguments']);
      }
      return $this->definition['access callback']();
    }

    return TRUE;
  }

views_handler::admin_summary ( ) [inherited]

Provide text for the administrative summary.

Reimplemented in views_handler_area, views_handler_field, views_handler_filter, views_handler_filter_boolean_operator, views_handler_filter_in_operator, views_handler_filter_numeric, views_handler_filter_string, views_handler_sort, views_handler_filter_history_user_timestamp, views_handler_filter_node_access, views_handler_filter_node_status, views_handler_filter_term_node_tid, views_handler_filter_node_tnid, views_handler_filter_node_tnid_child, and views_handler_filter_user_name.

Definition at line 647 of file handlers.inc.

{ }

views_handler::broken ( ) [inherited]

Determine if the handler is considered 'broken', meaning it's a a placeholder used when a handler can't be found.

Reimplemented in views_handler_area_broken, views_handler_argument_broken, views_handler_field_broken, views_handler_filter_broken, views_handler_relationship_broken, and views_handler_sort_broken.

Definition at line 716 of file handlers.inc.

{ }

views_handler::can_expose ( ) [inherited]

Determine if a handler can be exposed.

Reimplemented in views_handler_filter, views_handler_sort, views_handler_filter_node_access, views_handler_filter_node_status, views_handler_filter_node_tnid, and views_handler_filter_node_tnid_child.

Definition at line 487 of file handlers.inc.

{ return FALSE; }

views_handler::case_transform	(	$	string,
		$	option
	)			`[inherited]`

Transform a string by a certain method.

Parameters:

$string

The input you want to transform.

$option

How do you want to transform it, possible values:

upper: Uppercase the string.
lower: lowercase the string.
ucfirst: Make the first char uppercase.
ucwords: Make each word in the string uppercase.

Returns:: string The transformed string.

Definition at line 347 of file handlers.inc.

Referenced by views_handler_argument_string::summary_argument().

                                            {
    global $multibyte;

    switch ($option) {
      default:
        return $string;
      case 'upper':
        return drupal_strtoupper($string);
      case 'lower':
        return drupal_strtolower($string);
      case 'ucfirst':
        return drupal_strtoupper(drupal_substr($string, 0, 1)) . drupal_substr($string, 1);
      case 'ucwords':
        if ($multibyte == UNICODE_MULTIBYTE) {
          return mb_convert_case($string, MB_CASE_TITLE);
        }
        else {
          return ucwords($string);
        }
    }
  }

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_handler::ensure_my_table ( ) [inherited]

Ensure the main table for this handler is in the query.

This is used a lot.

Reimplemented in views_handler_area_broken, views_handler_argument_broken, views_handler_argument_many_to_one, views_handler_field_broken, views_handler_filter_broken, views_handler_filter_many_to_one, views_handler_relationship_broken, and views_handler_sort_broken.

Definition at line 633 of file handlers.inc.

References vpr().

                             {
    if (!isset($this->table_alias)) {
      if (!method_exists($this->query, 'ensure_table')) {
        vpr(t('Ensure my table called but query has no ensure_table method.'));
        return;
      }
      $this->table_alias = $this->query->ensure_table($this->table, $this->relationship);
    }
    return $this->table_alias;
  }

views_handler::expose_form	(	&$	form,
		&$	form_state
	)			`[inherited]`

Form for exposed handler options.

Reimplemented in views_handler_filter, views_handler_filter_in_operator, views_handler_sort, views_handler_filter_history_user_timestamp, and views_handler_filter_term_node_tid.

Definition at line 518 of file handlers.inc.

Referenced by views_handler::show_expose_form().

{ }

views_handler::expose_options ( ) [inherited]

Set new exposed option defaults when exposed setting is flipped on.

Reimplemented in views_handler_filter, views_handler_filter_boolean_operator, views_handler_filter_in_operator, and views_handler_sort.

Definition at line 493 of file handlers.inc.

{ }

views_handler::expose_submit	(	$	form,
		&$	form_state
	)			`[inherited]`

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

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

Definition at line 529 of file handlers.inc.

Referenced by views_handler_sort::options_submit(), and views_handler_filter::options_submit().

{ }

views_handler::expose_validate	(	$	form,
		&$	form_state
	)			`[inherited]`

Validate the options form.

Reimplemented in views_handler_filter.

Definition at line 523 of file handlers.inc.

Referenced by views_handler_sort::options_validate().

{ }

views_handler::exposed_form	(	&$	form,
		&$	form_state
	)			`[inherited]`

Render our chunk of the exposed handler form when selecting.

Reimplemented in views_handler_filter.

Definition at line 503 of file handlers.inc.

{ }

views_handler::exposed_info ( ) [inherited]

Get information about the exposed form for the form renderer.

Reimplemented in views_handler_filter.

Definition at line 498 of file handlers.inc.

{ }

views_handler::exposed_submit	(	&$	form,
		&$	form_state
	)			`[inherited]`

Submit the exposed handler form.

Definition at line 513 of file handlers.inc.

{ }

views_handler::exposed_validate	(	&$	form,
		&$	form_state
	)			`[inherited]`

Validate the exposed handler form.

Reimplemented in views_handler_filter_date, views_handler_filter_search, views_handler_filter_term_node_tid, and views_handler_filter_user_name.

Definition at line 508 of file handlers.inc.

{ }

views_handler::extra_options ( &$ option ) [inherited]

Provide defaults for the handler.

Definition at line 466 of file handlers.inc.

{ }

views_handler::extra_options_form	(	&$	form,
		&$	form_state
	)			`[inherited]`

Provide a form for setting options.

Reimplemented in views_handler_filter_term_node_tid, and views_handler_filter_term_node_tid_depth.

Definition at line 471 of file handlers.inc.

{ }

views_handler::extra_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.

Definition at line 482 of file handlers.inc.

{ }

views_handler::extra_options_validate	(	$	form,
		&$	form_state
	)			`[inherited]`

Validate the options form.

Definition at line 476 of file handlers.inc.

{ }

views_handler::get_field ( $ field = NULL ) [inherited]

Shortcut to get a handler's raw field value.

This should be overridden for handlers with formulae or other non-standard fields. Because this takes an argument, fields overriding this can just call return parent::get_field($formula)

Definition at line 285 of file handlers.inc.

References views_object::options().

Referenced by views_handler_filter_group_by_numeric::query(), views_handler_argument_group_by_numeric::query(), views_handler_sort_group_by_numeric::ui_name(), views_handler_filter_group_by_numeric::ui_name(), and views_handler_argument_group_by_numeric::ui_name().

                                    {
    if (!isset($field)) {
      if (!empty($this->formula)) {
        $field = $this->get_formula();
      }
      else {
        $field = $this->table_alias . '.' . $this->real_field;
      }
    }

    // If grouping, check to see if the aggregation method needs to modify the field.
    if ($this->view->display_handler->use_group_by()) {
      $this->view->init_query();
      if ($this->query) {
        $info = $this->query->get_aggregation_info();
        if (!empty($info[$this->options['group_type']]['method']) && function_exists($info[$this->options['group_type']]['method'])) {
          return $info[$this->options['group_type']]['method']($this->options['group_type'], $field);
        }
      }
    }

    return $field;
  }

views_handler::get_join ( ) [inherited]

Get the join object that should be used for this handler.

This method isn't used a great deal, but it's very handy for easily getting the join if it is necessary to make some changes to it, such as adding an 'extra'.

Definition at line 683 of file handlers.inc.

References views_get_table_join().

Referenced by views_handler_argument_many_to_one::summary_query().

                      {
    // get the join from this table that links back to the base table.
    // Determine the primary table to seek
    if (empty($this->query->relationships[$this->relationship])) {
      $base_table = $this->query->base_table;
    }
    else {
      $base_table = $this->query->relationships[$this->relationship]['base'];
    }

    $join = views_get_table_join($this->table, $base_table);
    if ($join) {
      return clone $join;
    }
  }

views_handler::groupby_form	(	&$	form,
		&$	form_state
	)			`[inherited]`

Provide a form for aggregation settings.

Reimplemented in views_handler_field_field.

Definition at line 420 of file handlers.inc.

References views_object::options(), views_handler::ui_name(), and views_object_types().

                                              {
    $view = &$form_state['view'];
    $display_id = $form_state['display_id'];
    $types = views_object_types();
    $type = $form_state['type'];
    $id = $form_state['id'];

    $form['#title'] = check_plain($view->display[$display_id]->display_title) . ': ';
    $form['#title'] .= t('Configure aggregation settings for @type %item', array('@type' => $types[$type]['lstitle'], '%item' => $this->ui_name()));

    $form['#section'] = $display_id . '-' . $type . '-' . $id;

    $view->init_query();
    $info = $view->query->get_aggregation_info();
    foreach ($info as $id => $aggregate) {
      $group_types[$id] = $aggregate['title'];
    }

    $form['group_type'] = array(
      '#type' => 'select',
      '#title' => t('Aggregation type'),
      '#default_value' => $this->options['group_type'],
      '#description' => t('Select the aggregation function to use on this field.'),
      '#options' => $group_types,
    );
  }

views_handler::groupby_form_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 in views_handler_field_field.

Definition at line 451 of file handlers.inc.

                                                     {
    $item =& $form_state['handler']->options;

    $item['group_type'] = $form_state['values']['options']['group_type'];
  }

views_handler::has_extra_options ( ) [inherited]

If a handler has 'extra options' it will get a little settings widget and another form called extra_options.

Reimplemented in views_handler_filter_term_node_tid.

Definition at line 461 of file handlers.inc.

{ return FALSE; }

views_handler_relationship::init	(	&$	view,
		&$	options
	)			`[inherited]`

Init handler to let relationships live on tables other than the table they operate on.

Reimplemented from views_handler.

Reimplemented in views_handler_relationship_entity_reverse, and views_handler_relationship_node_term_data.

Definition at line 40 of file views_handler_relationship.inc.

References views_object::$options.

                                   {
    parent::init($view, $options);
    if (isset($this->definition['relationship table'])) {
      $this->table = $this->definition['relationship table'];
    }
    if (isset($this->definition['relationship field'])) {
      // Set both real_field and field so custom handler
      // can rely on the old field value.
      $this->real_field = $this->field = $this->definition['relationship field'];
    }
  }

views_handler::is_exposed ( ) [inherited]

Determine if this item is 'exposed', meaning it provides form elements to let users modify the view.

Returns:: TRUE/FALSE

Definition at line 662 of file handlers.inc.

References views_object::options().

                        {
    return !empty($this->options['exposed']);
  }

views_handler_relationship::label ( ) [inherited]

Get this field's label.

Definition at line 55 of file views_handler_relationship.inc.

References views_object::options(), and views_handler::ui_name().

                   {
    if (!isset($this->options['label'])) {
      return $this->ui_name();
    }
    return $this->options['label'];
  }

views_handler::needs_style_plugin ( ) [inherited]

Determine if the argument needs a style plugin.

Returns:: TRUE/FALSE

Reimplemented in views_handler_argument.

Definition at line 654 of file handlers.inc.

{ return FALSE; }

views_handler_relationship_translation::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_handler_relationship.

Definition at line 10 of file views_handler_relationship_translation.inc.

References views_object::$options.

                               {
    $options = parent::option_definition();
    $options['language'] = array('default' => 'current');

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

Add a translation selector.

Reimplemented from views_handler_relationship.

Definition at line 20 of file views_handler_relationship_translation.inc.

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

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

    $options = array(
      'all' => t('All'),
      'current' => t('Current language'),
      'default' => t('Default language'),
    );
    $options = array_merge($options, locale_language_list());
    $form['language'] = array(
      '#type' => 'select',
      '#options' => $options,
      '#default_value' => $this->options['language'],
      '#title' => t('Translation option'),
      '#description' => t('The translation options allows you to select which translation or translations in a translation set join on. Select "Current language" or "Default language" to join on the translation in the current or default language respectively. Select a specific language to join on a translation in that language. If you select "All", each translation will create a new row, which may appear to cause duplicates.'),
    );
  }

views_handler::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 in views_handler_area_text, views_handler_argument, views_handler_field, views_handler_filter, views_handler_relationship_groupwise_max, and views_handler_sort.

Definition at line 409 of file handlers.inc.

{ }

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

Validate the options form.

Reimplemented in views_handler_argument, views_handler_field_serialized, views_handler_filter, views_handler_filter_date, and views_handler_sort.

Definition at line 372 of file handlers.inc.

{ }

views_handler::placeholder ( ) [inherited]

Provides a unique placeholders for handlers.

Definition at line 595 of file handlers.inc.

References views_object::options().

Referenced by views_handler_filter_search::query(), views_handler_argument_search::query(), views_handler_argument_node_uid_revision::query(), views_handler_field_field::query(), views_handler_filter_string::query(), views_handler_filter_group_by_numeric::query(), views_handler_argument_string::query(), views_handler_argument_numeric::query(), views_handler_argument_group_by_numeric::query(), views_handler_argument_formula::query(), and views_handler_argument_string::summary_query().

                         {
    return $this->query->placeholder($this->options['table'] . '_' . $this->options['field']);
  }

views_handler::post_execute ( &$ values ) [inherited]

Run after the view is executed, before the result is cached.

This gives all the handlers some time to modify values. This is primarily used so that handlers that pull up secondary data can put it in the $values so that the raw data can be utilized externally.

Reimplemented in views_handler_field_field.

Definition at line 590 of file handlers.inc.

{ }

views_handler::pre_query ( ) [inherited]

Run before the view is built.

This gives all the handlers some time to set up before any handler has been fully run.

Reimplemented in views_handler_argument_term_node_tid_depth_modifier.

Definition at line 581 of file handlers.inc.

{ }

views_handler_relationship_translation::query ( )

Called to implement a relationship in a query.

Reimplemented from views_handler_relationship.

Definition at line 41 of file views_handler_relationship_translation.inc.

References views_handler::ensure_my_table(), views_object::options(), and views_fetch_data().

                   {
    // Figure out what base table this relationship brings to the party.
    $table_data = views_fetch_data($this->definition['base']);
    $base_field = empty($this->definition['base field']) ? $table_data['table']['base']['field'] : $this->definition['base field'];

    $this->ensure_my_table();

    $def = $this->definition;
    $def['table'] = $this->definition['base'];
    $def['field'] = $base_field;
    $def['left_table'] = $this->table_alias;
    $def['left_field'] = $this->field;
    if (!empty($this->options['required'])) {
      $def['type'] = 'INNER';
    }

    $def['extra'] = array();
    if ($this->options['language'] != 'all') {
      switch ($this->options['language']) {
        case 'current':
          $def['extra'][] = array(
            'field' => 'language',
            'value' => '***CURRENT_LANGUAGE***',
          );
          break;
        case 'default':
          $def['extra'][] = array(
            'field' => 'language',
            'value' => '***DEFAULT_LANGUAGE***',
          );
          break;
        // Other values will be the language codes.
        default:
          $def['extra'][] = array(
            'field' => 'language',
            'value' => $this->options['language'],
          );
          break;
      }
    }

    if (!empty($def['join_handler']) && class_exists($def['join_handler'])) {
      $join = new $def['join_handler'];
    }
    else {
      $join = new views_join();
    }

    $join->definition = $def;
    $join->construct();
    $join->adjusted = TRUE;

    // use a short alias for this:
    $alias = $def['table'] . '_' . $this->table;

    $this->alias = $this->query->add_relationship($alias, $join, $this->definition['base'], $this->relationship);
  }

views_handler::sanitize_value	(	$	value,
		$	type = `NULL`
	)			`[inherited]`

Sanitize the value for output.

Parameters:

	$value	The value being rendered.
	$type	The type of sanitization needed. If not provided, check_plain() is used.

Definition at line 317 of file handlers.inc.

                                                {
    switch ($type) {
      case 'xss':
        $value = filter_xss($value);
        break;
      case 'url':
        $value = check_url($value);
        break;
      default:
        $value = check_plain($value);
        break;
    }
    return $value;
  }

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_handler::set_relationship ( ) [inherited]

Called just prior to query(), this lets a handler set up any relationship it needs.

Definition at line 603 of file handlers.inc.

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

                              {
    // Ensure this gets set to something.
    $this->relationship = NULL;

    // Don't process non-existant relationships.
    if (empty($this->options['relationship']) || $this->options['relationship'] == 'none') {
      return;
    }

    $relationship = $this->options['relationship'];

    // Ignore missing/broken relationships.
    if (empty($this->view->relationship[$relationship])) {
      return;
    }

    // Check to see if the relationship has already processed. If not, then we
    // cannot process it.
    if (empty($this->view->relationship[$relationship]->alias)) {
      return;
    }

    // Finally!
    $this->relationship = $this->view->relationship[$relationship]->alias;
  }

views_handler::show_expose_button	(	&$	form,
		&$	form_state
	)			`[inherited]`

Shortcut to display the expose/hide button.

Reimplemented in views_handler_filter, and views_handler_sort.

Definition at line 534 of file handlers.inc.

{ }

views_handler::show_expose_form	(	&$	form,
		&$	form_state
	)			`[inherited]`

Shortcut to display the exposed options form.

Definition at line 539 of file handlers.inc.

References views_handler::expose_form(), and views_object::options().

Referenced by views_handler_sort::options_form(), and views_handler_filter::options_form().

                                                  {
    if (empty($this->options['exposed'])) {
      return;
    }

    $this->expose_form($form, $form_state);

    // When we click the expose button, we add new gadgets to the form but they
    // have no data in $_POST so their defaults get wiped out. This prevents
    // these defaults from getting wiped out. This setting will only be TRUE
    // during a 2nd pass rerender.
    if (!empty($form_state['force_expose_options'])) {
      foreach (element_children($form['expose']) as $id) {
        if (isset($form['expose'][$id]['#default_value']) && !isset($form['expose'][$id]['#value'])) {
          $form['expose'][$id]['#value'] = $form['expose'][$id]['#default_value'];
        }
      }
    }
  }

views_handler::store_exposed_input	(	$	input,
		$	status
	)			`[inherited]`

If set to remember exposed input in the session, store it there.

Reimplemented in views_handler_filter.

Definition at line 674 of file handlers.inc.

{ return TRUE; }

views_handler::ui_name ( $ short = FALSE ) [inherited]

Return a string representing this handler's name in the UI.

Reimplemented in views_handler_area_broken, views_handler_argument_broken, views_handler_argument_group_by_numeric, views_handler_field, views_handler_field_broken, views_handler_filter_broken, views_handler_filter_group_by_numeric, views_handler_relationship_broken, views_handler_sort_broken, and views_handler_sort_group_by_numeric.

Definition at line 269 of file handlers.inc.

References views_object::options().

Referenced by views_handler::groupby_form(), views_handler_relationship::label(), views_handler_area::label(), and views_handler_filter_in_operator::validate().

                                   {
    if (!empty($this->options['ui_name'])) {
      $title = check_plain($this->options['ui_name']);
      return $title;
    }
    $title = ($short && isset($this->definition['title short'])) ? $this->definition['title short'] : $this->definition['title'];
    return t('!group: !title', array('!group' => $this->definition['group'], '!title' => $title));
  }

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_handler_relationship::use_group_by ( ) [inherited]

You can't groupby a relationship.

Reimplemented from views_handler.

Definition at line 152 of file views_handler_relationship.inc.

                          {
    return FALSE;
  }

views_handler::validate ( ) [inherited]

Validates the handler against the complete View.

This is called when the complete View is being validated. For validating the handler options form use options_validate().

See also:: views_handler::options_validate()

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

Reimplemented in views_handler_filter_in_operator.

Definition at line 710 of file handlers.inc.

{ return array(); }

Member Data Documentation

views_handler::$handler_type = NULL [inherited]

The type of the handler, for example filter/footer/field.

Definition at line 170 of file handlers.inc.

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_handler::$real_field [inherited]

The actual field in the database table, maybe different on other kind of query plugins/special handlers.

Definition at line 181 of file handlers.inc.

views_handler::$relationship = NULL [inherited]

The relationship used for this field.

Definition at line 186 of file handlers.inc.

Referenced by views_handler_field_entity::query(), and views_handler::set_relationship().

views_handler::$table_alias [inherited]

The alias of the table of this handler which is used in the query.

Definition at line 175 of file handlers.inc.

Referenced by views_handler_field::add_additional_fields().

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

modules/translation/views_handler_relationship_translation.inc

views_handler_relationship_translation Class Reference [Views' relationship handlers]

Public Member Functions

Public Attributes

Detailed Description

Member Function Documentation

Member Data Documentation

views_handler_relationship_translation Class Reference
[Views' relationship handlers]