Field handler to provide simple renderer that allows linking to a node. More...

Inheritance diagram for views_handler_field_search_score:

Public Member Functions
	option_definition ()
	Information about options for all kinds of purposes will be held here.
	options_form (&$form, &$form_state)
	Default options form that provides the label widget that all fields should have.
	query ()
	Called to add the field to a query.
	render ($values)
	Render the field.
	construct ()
	Construct a new field handler.
	allow_advanced_render ()
	Determine if this field can allow advanced rendering.
	init (&$view, &$options)
	init the handler with necessary data.
	add_additional_fields ($fields=NULL)
	Add 'additional' fields to the query.
	click_sort ($order)
	Called to determine what to tell the clicksorter.
	click_sortable ()
	Determine if this field is click sortable.
	label ()
	Get this field's label.
	element_type ($none_supported=FALSE, $default_empty=FALSE, $inline=FALSE)
	Return an HTML element based upon the field's element type.
	element_label_type ($none_supported=FALSE, $default_empty=FALSE)
	Return an HTML element for the label based upon the field's element type.
	element_wrapper_type ($none_supported=FALSE, $default_empty=FALSE)
	Return an HTML element for the wrapper based upon the field's element type.
	get_elements ()
	Provide a list of elements valid for field HTML.
	element_classes ($row_index=NULL)
	Return the class of the field.
	tokenize_value ($value, $row_index=NULL)
	Replace a value with tokens from the last field.
	element_label_classes ($row_index=NULL)
	Return the class of the field's label.
	element_wrapper_classes ($row_index=NULL)
	Return the class of the field's wrapper.
	get_value ($values, $field=NULL)
	Get the value that's supposed to be rendered.
	options_submit (&$form, &$form_state)
	Performs some cleanup tasks on the options array before saving it.
	admin_summary ()
	Provide extra data to the administration form.
	pre_render (&$values)
	Run before any fields are rendered.
	advanced_render ($values)
	Render a field using advanced settings.
	render_text ($alter)
	Perform an advanced text render for the item.
	render_altered ($alter, $tokens)
	Render this field as altered text, from a fieldset set by the user.
	render_trim_text ($alter, $value)
	Trim the field down to the specified length.
	render_as_link ($alter, $text, $tokens)
	Render this field as a link, with the info from a fieldset set by the user.
	get_render_tokens ($item)
	Get the 'render' tokens to use for advanced rendering.
	add_self_tokens (&$tokens, $item)
	Add any special tokens this field might use for itself.
	document_self_tokens (&$tokens)
	Document any special tokens this field might use for itself.
	theme ($values)
	Call out to the theme() function, which probably just calls render() but allows sites to override output fairly easily.
	theme_functions ()
	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.
	use_group_by ()
	Provides the handler some groupby.
	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.
	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.
	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
	$field_alias = 'unknown'
	$aliases = array()
	$additional_fields = array()
	$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

Field handler to provide simple renderer that allows linking to a node.

Definition at line 7 of file views_handler_field_search_score.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_field::add_additional_fields ( $ fields = NULL ) [inherited]

Add 'additional' fields to the query.

Parameters:

$fields

An array of fields. The key is an identifier used to later find the field alias used. The value is either a string in which case it's assumed to be a field on this handler's table; or it's an array in the form of

 array('table' => $tablename, 'field' => $fieldname)

Definition at line 100 of file views_handler_field.inc.

References views_handler::$table_alias, views_object::options(), and views_handler_field::query().

                                                 {
    if (!isset($fields)) {
      // notice check
      if (empty($this->additional_fields)) {
        return;
      }
      $fields = $this->additional_fields;
    }

    $group_params = array();
    if ($this->options['group_type'] != 'group') {
      $group_params = array(
        'function' => $this->options['group_type'],
      );
    }

    if (!empty($fields) && is_array($fields)) {
      foreach ($fields as $identifier => $info) {
        if (is_array($info)) {
          if (isset($info['table'])) {
            $table_alias = $this->query->ensure_table($info['table'], $this->relationship);
          }
          else {
            $table_alias = $this->table_alias;
          }

          if (empty($table_alias)) {
            debug(t('Handler @handler tried to add additional_field @identifier but @table could not be added!', array('@handler' => $this->definition['handler'], '@identifier' => $identifier, '@table' => $info['table'])));
            $this->aliases[$identifier] = 'broken';
            continue;
          }

          $params = array();
          if (!empty($info['params'])) {
            $params = $info['params'];
          }

          $params += $group_params;
          $this->aliases[$identifier] = $this->query->add_field($table_alias, $info['field'], NULL, $params);
        }
        else {
          $this->aliases[$info] = $this->query->add_field($this->table_alias, $info, NULL, $group_params);
        }
      }
    }
  }

views_handler_field::add_self_tokens	(	&$	tokens,
		$	item
	)			`[inherited]`

Add any special tokens this field might use for itself.

This method is intended to be overridden by items that generate fields as a list. For example, the field that displays all terms on a node might have tokens for the tid and the term.

By convention, tokens should follow the format of [token-subtoken] where token is the field ID and subtoken is the field. If the field ID is terms, then the tokens might be [terms-tid] and [terms-name].

Reimplemented in views_handler_field_field, views_handler_field_profile_list, views_handler_field_term_node_tid, and views_handler_field_user_roles.

Definition at line 1371 of file views_handler_field.inc.

{ }

views_handler_field::admin_summary ( ) [inherited]

Provide extra data to the administration form.

Reimplemented from views_handler.

Definition at line 974 of file views_handler_field.inc.

                           {
    return $this->label();
  }

views_handler_field::advanced_render ( $ values ) [inherited]

Render a field using advanced settings.

This renders a field normally, then decides if render-as-link and text-replacement rendering is necessary.

Definition at line 1006 of file views_handler_field.inc.

                                    {
    if ($this->allow_advanced_render() && method_exists($this, 'render_item')) {
      $raw_items = $this->get_items($values);
    }
    else {
      $value = $this->render($values);
      if (is_array($value)) {
        $value = drupal_render($value);
      }
      $this->last_render = $value;
      $this->original_value = $value;
    }

    if ($this->allow_advanced_render()) {
      $tokens = NULL;
      if (method_exists($this, 'render_item')) {
        $items = array();
        foreach ($raw_items as $count => $item) {
          $value = $this->render_item($count, $item);
          if (is_array($value)) {
            $value = drupal_render($value);
          }
          $this->last_render = $value;
          $this->original_value = $this->last_render;

          $alter = $item + $this->options['alter'];
          $alter['phase'] = VIEWS_HANDLER_RENDER_TEXT_PHASE_SINGLE_ITEM;
          $items[] = $this->render_text($alter);
        }

        $value = $this->render_items($items);
      }
      else {
        $alter = array('phase' => VIEWS_HANDLER_RENDER_TEXT_PHASE_COMPLETELY) + $this->options['alter'];
        $value = $this->render_text($alter);
      }

      if (is_array($value)) {
        $value = drupal_render($value);
      }
      // This happens here so that render_as_link can get the unaltered value of
      // this field as a token rather than the altered value.
      $this->last_render = $value;
    }

    if (empty($this->last_render)) {
      if (($this->last_render !== 0 && $this->last_render !== '0') || !empty($this->options['empty_zero'])) {
        $alter = $this->options['alter'];
        $alter['alter_text'] = 1;
        $alter['text'] = $this->options['empty'];
        $alter['phase'] = VIEWS_HANDLER_RENDER_TEXT_PHASE_EMPTY;
        $this->last_render = $this->render_text($alter);
      }
    }

    return $this->last_render;
  }

views_handler_field::allow_advanced_render ( ) [inherited]

Determine if this field can allow advanced rendering.

Fields can set this to FALSE if they do not wish to allow token based rewriting or link-making.

Reimplemented in views_handler_field_prerender_list.

Definition at line 70 of file views_handler_field.inc.

                                   {
    return TRUE;
  }

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_handler_field::click_sort ( $ order ) [inherited]

Called to determine what to tell the clicksorter.

Reimplemented in views_handler_field_field.

Definition at line 150 of file views_handler_field.inc.

References views_object::options(), and views_handler_field::query().

                              {
    if (isset($this->field_alias)) {
      // Since fields should always have themselves already added, just
      // add a sort on the field.
      $params = $this->options['group_type'] != 'group' ? array('function' => $this->options['group_type']) : array();
      $this->query->add_orderby(NULL, NULL, $order, $this->field_alias, $params);
    }
  }

views_handler_field::click_sortable ( ) [inherited]

Determine if this field is click sortable.

Reimplemented in views_handler_field_field.

Definition at line 162 of file views_handler_field.inc.

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

views_handler_field::construct ( ) [inherited]

Construct a new field handler.

Reimplemented from views_object.

Definition at line 51 of file views_handler_field.inc.

References views_object::options().

                       {
    parent::construct();

    $this->additional_fields = array();
    if (!empty($this->definition['additional fields'])) {
      $this->additional_fields = $this->definition['additional fields'];
    }

    if (!isset($this->options['exclude'])) {
      $this->options['exclude'] = '';
    }
  }

views_handler_field::document_self_tokens ( &$ tokens ) [inherited]

Document any special tokens this field might use for itself.

See also:: add_self_tokens() for details.

Reimplemented in views_handler_field_field, views_handler_field_profile_list, views_handler_field_term_node_tid, and views_handler_field_user_roles.

Definition at line 1378 of file views_handler_field.inc.

{ }

views_handler_field::element_classes ( $ row_index = NULL ) [inherited]

Return the class of the field.

Definition at line 277 of file views_handler_field.inc.

References views_object::options(), views_handler_field::tokenize_value(), and views_clean_css_identifier().

                                              {
    $classes = explode(' ', $this->options['element_class']);
    foreach ($classes as &$class) {
      $class = $this->tokenize_value($class, $row_index);
      $class = views_clean_css_identifier($class);
    }
    return implode(' ', $classes);
  }

views_handler_field::element_label_classes ( $ row_index = NULL ) [inherited]

Return the class of the field's label.

Definition at line 327 of file views_handler_field.inc.

References views_object::options(), views_handler_field::tokenize_value(), and views_clean_css_identifier().

                                                    {
    $classes = explode(' ', $this->options['element_label_class']);
    foreach ($classes as &$class) {
      $class = $this->tokenize_value($class, $row_index);
      $class = views_clean_css_identifier($class);
    }
    return implode(' ', $classes);
  }

views_handler_field::element_label_type	(	$	none_supported = `FALSE`,
		$	default_empty = `FALSE`
	)			`[inherited]`

Return an HTML element for the label based upon the field's element type.

Definition at line 207 of file views_handler_field.inc.

References views_object::options().

                                                                               {
    if ($none_supported) {
      if ($this->options['element_label_type'] === '0') {
        return '';
      }
    }
    if ($this->options['element_label_type']) {
      return check_plain($this->options['element_label_type']);
    }

    if ($default_empty) {
      return '';
    }

    return 'span';
  }

views_handler_field::element_type	(	$	none_supported = `FALSE`,
		$	default_empty = `FALSE`,
		$	inline = `FALSE`
	)			`[inherited]`

Return an HTML element based upon the field's element type.

Reimplemented in views_handler_field_markup, and views_handler_field_user_picture.

Definition at line 179 of file views_handler_field.inc.

References views_object::options().

                                                                                          {
    if ($none_supported) {
      if ($this->options['element_type'] === '0') {
        return '';
      }
    }
    if ($this->options['element_type']) {
      return check_plain($this->options['element_type']);
    }

    if ($default_empty) {
      return '';
    }

    if ($inline) {
      return 'span';
    }

    if (isset($this->definition['element type'])) {
      return $this->definition['element type'];
    }

    return 'span';
  }

views_handler_field::element_wrapper_classes ( $ row_index = NULL ) [inherited]

Return the class of the field's wrapper.

Definition at line 339 of file views_handler_field.inc.

References views_object::options(), views_handler_field::tokenize_value(), and views_clean_css_identifier().

                                                      {
    $classes = explode(' ', $this->options['element_wrapper_class']);
    foreach ($classes as &$class) {
      $class = $this->tokenize_value($class, $row_index);
      $class = views_clean_css_identifier($class);
    }
    return implode(' ', $classes);
  }

views_handler_field::element_wrapper_type	(	$	none_supported = `FALSE`,
		$	default_empty = `FALSE`
	)			`[inherited]`

Return an HTML element for the wrapper based upon the field's element type.

Definition at line 227 of file views_handler_field.inc.

References views_object::options().

                                                                                 {
    if ($none_supported) {
      if ($this->options['element_wrapper_type'] === '0') {
        return 0;
      }
    }
    if ($this->options['element_wrapper_type']) {
      return check_plain($this->options['element_wrapper_type']);
    }

    if ($default_empty) {
      return '';
    }

    return 'div';
  }

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_field::get_elements ( ) [inherited]

Provide a list of elements valid for field HTML.

This function can be overridden by fields that want more or fewer elements available, though this seems like it would be an incredibly rare occurence.

Definition at line 251 of file views_handler_field.inc.

                          {
    static $elements = NULL;
    if (!isset($elements)) {
      $elements = variable_get('views_field_rewrite_elements', array(
        '' => t('- Use default -'),
        '0' => t('- None -'),
        'div' => 'DIV',
        'span' => 'SPAN',
        'h1' => 'H1',
        'h2' => 'H2',
        'h3' => 'H3',
        'h4' => 'H4',
        'h5' => 'H5',
        'h6' => 'H6',
        'p' => 'P',
        'strong' => 'STRONG',
        'em' => 'EM',
      ));
    }

    return $elements;
  }

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_field::get_render_tokens ( $ item ) [inherited]

Get the 'render' tokens to use for advanced rendering.

This runs through all of the fields and arguments that are available and gets their values. This will then be used in one giant str_replace().

Definition at line 1318 of file views_handler_field.inc.

Referenced by views_handler_field_math::render().

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

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

    // Now add replacements for our fields.
    foreach ($this->view->display_handler->get_handlers('field') as $field => $handler) {
      if (isset($handler->last_render)) {
        $tokens["[$field]"] = $handler->last_render;
      }
      else {
        $tokens["[$field]"] = '';
      }
      if (!empty($item)) {
        $this->add_self_tokens($tokens, $item);
      }

      // We only use fields up to (and including) this one.
      if ($field == $this->options['id']) {
        break;
      }
    }

    // Store the tokens for the row so we can reference them later if necessary.
    $this->view->style_plugin->render_tokens[$this->view->row_index] = $tokens;
    $this->last_tokens = $tokens;
    return $tokens;
  }

views_handler_field::get_value	(	$	values,
		$	field = `NULL`
	)			`[inherited]`

Get the value that's supposed to be rendered.

This api exists so that other modules can easy set the values of the field without having the need to change the render method as well.

Parameters:

	$values	An object containing all retrieved values.
	$field	Optional name of the field where the value is stored.

Reimplemented in views_handler_field_entity, and views_handler_field_field.

Definition at line 359 of file views_handler_field.inc.

                                             {
    $alias = isset($field) ? $this->aliases[$field] : $this->field_alias;
    if (isset($values->{$alias})) {
      return $values->{$alias};
    }
  }

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_field::init	(	&$	view,
		&$	options
	)			`[inherited]`

init the handler with necessary data.

Parameters:

	$view	The $view object this handler is attached to.
	$options	The item from the database; the actual contents of this will vary based upon the type of handler.

Reimplemented from views_handler.

Reimplemented in views_handler_field_boolean, views_handler_field_entity, views_handler_field_comment, views_handler_field_comment_username, views_handler_field_node_new_comments, views_handler_field_field, views_handler_field_history_user_timestamp, views_handler_field_node, views_handler_field_node_revision, views_handler_field_accesslog_path, views_handler_field_file, views_handler_field_term_node_tid, views_handler_field_user, and views_handler_field_user_name.

Definition at line 74 of file views_handler_field.inc.

References views_object::$options.

                                   {
    parent::init($view, $options);
  }

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_field::label ( ) [inherited]

Get this field's label.

Definition at line 169 of file views_handler_field.inc.

References views_object::options().

                   {
    if (!isset($this->options['label'])) {
      return '';
    }
    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_field_search_score::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_field_numeric.

Definition at line 8 of file views_handler_field_search_score.inc.

References views_object::$options.

                               {
    $options = parent::option_definition();

    $options['alternate_sort'] = array('default' => '');
    $options['alternate_order'] = array('default' => 'asc');

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

Default options form that provides the label widget that all fields should have.

Reimplemented from views_handler_field_numeric.

Definition at line 17 of file views_handler_field_search_score.inc.

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

                                              {
    $style_options = $this->view->display_handler->get_option('style_options');
    if (isset($style_options['default']) && $style_options['default'] == $this->options['id']) {
      $handlers = $this->view->display_handler->get_handlers('field');
      $options = array('' => t('No alternate'));
      foreach ($handlers as $id => $handler) {
        $options[$id] = $handler->ui_name();
      }

      $form['alternate_sort'] = array(
        '#type' => 'select',
        '#title' => t('Alternative sort'),
        '#description' => t('Pick an alternative default table sort field to use when the search score field is unavailable.'),
        '#options' => $options,
        '#default_value' => $this->options['alternate_sort'],
      );

      $form['alternate_order'] = array(
        '#type' => 'select',
        '#title' => t('Alternate sort order'),
        '#options' => array('asc' => t('Ascending'), 'desc' => t('Descending')),
        '#default_value' => $this->options['alternate_order'],
      );
    }

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

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

Performs some cleanup tasks on the options array before saving it.

Reimplemented from views_handler.

Definition at line 424 of file views_handler_field.inc.

                                                {
    $options = &$form_state['values']['options'];
    $types = array('element_type', 'element_label_type', 'element_wrapper_type');
    $classes = array_combine(array('element_class', 'element_label_class', 'element_wrapper_class'), $types);

    foreach ($types as $type) {
      if (!$options[$type . '_enable']) {
        $options[$type] = '';
      }
    }

    foreach ($classes as $class => $type) {
      if (!$options[$class . '_enable'] || !$options[$type . '_enable']) {
        $options[$class] = '';
      }
    }

    if (empty($options['custom_label'])) {
      $options['label'] = '';
      $options['element_label_colon'] = FALSE;
    }
  }

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_field::pre_render ( &$ values ) [inherited]

Run before any fields are rendered.

This gives the handlers some time to set up before any handler has been rendered.

Parameters:

$values

An array of all objects returned from the query.

Reimplemented in views_handler_field_contextual_links, views_handler_field_entity, views_handler_field_machine_name, views_handler_field_node_new_comments, views_handler_field_profile_list, views_handler_field_term_node_tid, views_handler_field_user_permissions, and views_handler_field_user_roles.

Definition at line 987 of file views_handler_field.inc.

{ }

views_handler_field_search_score::query ( )

Called to add the field to a query.

Reimplemented from views_handler_field.

Definition at line 45 of file views_handler_field_search_score.inc.

References views_object::options().

                   {
    // Check to see if the search filter added 'score' to the table.
    // Our filter stores it as $handler->search_score -- and we also
    // need to check its relationship to make sure that we're using the same
    // one or obviously this won't work.
    foreach ($this->view->filter as $handler) {
      if (isset($handler->search_score) && $handler->relationship == $this->relationship) {
        $this->field_alias = $handler->search_score;
        $this->table_alias = $handler->table_alias;
        return;
      }
    }

    // Hide this field if no search filter is in place.
    $this->options['exclude'] = TRUE;
    if (!empty($this->options['alternate_sort'])) {
      if (isset($this->view->style_plugin->options['default']) && $this->view->style_plugin->options['default'] == $this->options['id']) {
        // Since the style handler initiates fields, we plug these values right into the active handler.
        $this->view->style_plugin->options['default'] = $this->options['alternate_sort'];
        $this->view->style_plugin->options['order'] = $this->options['alternate_order'];
      }
    }
  }

views_handler_field_search_score::render ( $ values )

Render the field.

Parameters:

$values

The values retrieved from the database.

Reimplemented from views_handler_field_numeric.

Definition at line 69 of file views_handler_field_search_score.inc.

                           {
    // Only render if we exist.
    if (isset($this->table_alias)) {
      return parent::render($values);
    }
  }

views_handler_field::render_altered	(	$	alter,
		$	tokens
	)			`[inherited]`

Render this field as altered text, from a fieldset set by the user.

Definition at line 1147 of file views_handler_field.inc.

Referenced by views_handler_field::tokenize_value().

                                           {
    // Filter this right away as our substitutions are already sanitized.
    $value = filter_xss_admin($alter['text']);
    $value = strtr($value, $tokens);

    return $value;
  }

views_handler_field::render_as_link	(	$	alter,
		$	text,
		$	tokens
	)			`[inherited]`

Render this field as a link, with the info from a fieldset set by the user.

Definition at line 1172 of file views_handler_field.inc.

                                                  {
    $value = '';

    if (!empty($alter['prefix'])) {
      $value .= filter_xss_admin(strtr($alter['prefix'], $tokens));
    }

    $options = array(
      'html' => TRUE,
      'absolute' => !empty($alter['absolute']) ? TRUE : FALSE,
    );

    // $path will be run through check_url() by l() so we do not need to
    // sanitize it ourselves.
    $path = $alter['path'];

    // strip_tags() removes <front>, so check whether its different to front.
    if ($path != '<front>') {
      // Use strip tags as there should never be HTML in the path.
      // However, we need to preserve special characters like " that
      // were removed by check_plain().
      $path = strip_tags(decode_entities(strtr($path, $tokens)));

      if (!empty($alter['path_case']) && $alter['path_case'] != 'none') {
        $path = $this->case_transform($path, $this->options['alter']['path_case']);
      }

      if (!empty($alter['replace_spaces'])) {
        $path = str_replace(' ', '-', $path);
      }
    }

    // Parse the URL and move any query and fragment parameters out of the path.
    $url = parse_url($path);

    // Seriously malformed URLs may return FALSE or empty arrays.
    if (empty($url)) {
      return $text;
    }

    // If the path is empty do not build a link around the given text and return
    // it as is.
    // http://www.example.com URLs will not have a $url['path'], so check host as well.
    if (empty($url['path']) && empty($url['host']) && empty($url['fragment'])) {
      return $text;
    }

    // If no scheme is provided in the $path, assign the default 'http://'.
    // This allows a url of 'www.example.com' to be converted to 'http://www.example.com'.
    // Only do this on for external URLs.
    if ($alter['external']){
      if (!isset($url['scheme'])) {
        // There is no scheme, add the default 'http://' to the $path.
        $path = "http://$path";
        // Reset the $url array to include the new scheme.
        $url = parse_url($path);
      }
    }

    if (isset($url['query'])) {
      $path = strtr($path, array('?' . $url['query'] => ''));
      $options['query'] = drupal_get_query_array($url['query']);
    }
    if (isset($url['fragment'])) {
      $path = strtr($path, array('#' . $url['fragment'] => ''));
      // If the path is empty we want to have a fragment for the current site.
      if ($path == '') {
        $options['external'] = TRUE;
      }
      $options['fragment'] = $url['fragment'];
    }

    $alt = strtr($alter['alt'], $tokens);
    // Set the title attribute of the link only if it improves accessibility
    if ($alt && $alt != $text) {
      $options['attributes']['title'] = decode_entities($alt);
    }

    $class = strtr($alter['link_class'], $tokens);
    if ($class) {
      $options['attributes']['class'] = array($class);
    }

    if (!empty($alter['rel']) && $rel = strtr($alter['rel'], $tokens)) {
      $options['attributes']['rel'] = $rel;
    }

    $target = check_plain(trim(strtr($alter['target'],$tokens)));
    if (!empty($target)) {
      $options['attributes']['target'] = $target;
    }

    // Allow the addition of arbitrary attributes to links. Additional attributes
    // currently can only be altered in preprocessors and not within the UI.
    if (isset($alter['link_attributes']) && is_array($alter['link_attributes'])) {
      foreach ($alter['link_attributes'] as $key => $attribute) {
        if (!isset($options['attributes'][$key])) {
          $options['attributes'][$key] = strtr($attribute, $tokens);
        }
      }
    }

    // If the query and fragment were programatically assigned overwrite any
    // parsed values.
    if (isset($alter['query'])) {
      // Convert the query to a string, perform token replacement, and then
      // convert back to an array form for l().
      $options['query'] = drupal_http_build_query($alter['query']);
      $options['query'] = strtr($options['query'], $tokens);
      $options['query'] = drupal_get_query_array($options['query']);
    }
    if (isset($alter['alias'])) {
      // Alias is a boolean field, so no token.
      $options['alias'] = $alter['alias'];
    }
    if (isset($alter['fragment'])) {
      $options['fragment'] = strtr($alter['fragment'], $tokens);
    }
    if (isset($alter['language'])) {
      $options['language'] = $alter['language'];
    }

    // If the url came from entity_uri(), pass along the required options.
    if (isset($alter['entity'])) {
      $options['entity'] = $alter['entity'];
    }
    if (isset($alter['entity_type'])) {
      $options['entity_type'] = $alter['entity_type'];
    }

    $value .= l($text, $path, $options);

    if (!empty($alter['suffix'])) {
      $value .= filter_xss_admin(strtr($alter['suffix'], $tokens));
    }

    return $value;
  }

views_handler_field::render_text ( $ alter ) [inherited]

Perform an advanced text render for the item.

This is separated out as some fields may render lists, and this allows each item to be handled individually.

Definition at line 1070 of file views_handler_field.inc.

                               {
    $value = $this->last_render;

    if (!empty($alter['alter_text']) && $alter['text'] !== '') {
      $tokens = $this->get_render_tokens($alter);
      $value = $this->render_altered($alter, $tokens);
    }

    if (!empty($this->options['alter']['trim_whitespace'])) {
      $value = trim($value);
    }

    // Check if there should be no further rewrite for empty values.
    $no_rewrite_for_empty = $this->options['hide_alter_empty'] && empty($this->original_value);

    // Check whether the value is empty and return nothing, so the field isn't rendered.
    // First check whether the field should be hidden if the value(hide_alter_empty = TRUE) /the rewrite is empty (hide_alter_empty = FALSE).
    // For numeric values you can specify whether "0"/0 should be empty.
    if ((($this->options['hide_empty'] && empty($value))
        || ($alter['phase'] != VIEWS_HANDLER_RENDER_TEXT_PHASE_EMPTY && $no_rewrite_for_empty))
      && (($value !== 0 && $value !== '0')
        || $this->options['empty_zero'])) {
      return '';
    }
    // Only in empty phase.
    if ($alter['phase'] == VIEWS_HANDLER_RENDER_TEXT_PHASE_EMPTY && $no_rewrite_for_empty) {
      // If we got here then $alter contains the value of "No results text"
      // and so there is nothing left to do.
      return $value;
    }

    if (!empty($alter['strip_tags'])) {
      $value = strip_tags($value, $alter['preserve_tags']);
    }

    $suffix = '';
    if (!empty($alter['trim']) && !empty($alter['max_length'])) {
      $length = strlen($value);
      $value = $this->render_trim_text($alter, $value);
      if ($this->options['alter']['more_link'] && strlen($value) < $length) {
        $tokens = $this->get_render_tokens($alter);
        $more_link_text = $this->options['alter']['more_link_text'] ? $this->options['alter']['more_link_text'] : t('more');
        $more_link_text = strtr(filter_xss_admin($more_link_text), $tokens);
        $more_link_path = $this->options['alter']['more_link_path'];
        $more_link_path = strip_tags(decode_entities(strtr($more_link_path, $tokens)));

        // Take sure that paths which was runned through url() does work as well.
        $base_path = base_path();
        // Checks whether the path starts with the base_path.
        if (strpos($more_link_path, $base_path) === 0) {
          $more_link_path = drupal_substr($more_link_path, drupal_strlen($base_path));
        }

        $more_link = l($more_link_text, $more_link_path);

        $suffix .= " " . $more_link;
      }
    }

    if (!empty($alter['nl2br'])) {
      $value = nl2br($value);
    }
    $this->last_render_text = $value;

    if (!empty($alter['make_link']) && !empty($alter['path'])) {
      if (!isset($tokens)) {
       $tokens = $this->get_render_tokens($alter);
      }
      $value = $this->render_as_link($alter, $value, $tokens);
    }

    return $value . $suffix;
  }

views_handler_field::render_trim_text	(	$	alter,
		$	value
	)			`[inherited]`

Trim the field down to the specified length.

Definition at line 1158 of file views_handler_field.inc.

References views_trim_text().

                                            {
    if (!empty($alter['strip_tags'])) {
      // NOTE: It's possible that some external fields might override the
      // element type so if someone from, say, CCK runs into a bug here,
      // this may be why =)
      $this->definition['element type'] = 'span';
    }
    return views_trim_text($alter, $value);
  }

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_field::theme ( $ values ) [inherited]

Call out to the theme() function, which probably just calls render() but allows sites to override output fairly easily.

Definition at line 1384 of file views_handler_field.inc.

Referenced by views_handler_field_user_picture::render(), views_handler_field_history_user_timestamp::render(), views_handler_field_ncs_last_comment_name::render(), views_handler_field_prerender_list::render(), and views_handler_field_prerender_list::render_items().

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

views_handler_field::tokenize_value	(	$	value,
		$	row_index = `NULL`
	)			`[inherited]`

Replace a value with tokens from the last field.

This function actually figures out which field was last and uses its tokens so they will all be available.

Definition at line 292 of file views_handler_field.inc.

References views_object::options(), and views_handler_field::render_altered().

Referenced by views_handler_field::element_classes(), views_handler_field::element_label_classes(), and views_handler_field::element_wrapper_classes().

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

      // Use isset() because empty() will trigger on 0 and 0 is
      // the first row.
      if (isset($row_index) && isset($this->view->style_plugin->render_tokens[$row_index])) {
        $tokens = $this->view->style_plugin->render_tokens[$row_index];
      }
      else {
        // Get tokens from the last field.
        $last_field = end($this->view->field);
        if (isset($last_field->last_tokens)) {
          $tokens = $last_field->last_tokens;
        }
        else {
          $tokens = $last_field->get_render_tokens($fake_item);
        }
      }

      $value = strip_tags($this->render_altered($fake_item, $tokens));
      if (!empty($this->options['alter']['trim_whitespace'])) {
        $value = trim($value);
      }
    }

    return $value;
  }

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

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

Reimplemented from views_handler.

Reimplemented in views_handler_field_broken.

Definition at line 1419 of file views_handler_field.inc.

                                   {
    return $this->get_field(parent::ui_name($short));
  }

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

Provides the handler some groupby.

Reimplemented in views_handler_area, and views_handler_relationship.

Definition at line 414 of file handlers.inc.

                          {
    return TRUE;
  }

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/search/views_handler_field_search_score.inc

views_handler_field_search_score Class Reference [Views' field handlers]

Public Member Functions

Public Attributes

Detailed Description

Member Function Documentation

Member Data Documentation

views_handler_field_search_score Class Reference
[Views' field handlers]