Argument handler for to modify depth for a previous term. More...

Inheritance diagram for views_handler_argument_term_node_tid_depth_modifier:

Public Member Functions
	options_form (&$form, &$form_state)
	Build the options form.
	query ($group_by=FALSE)
	Set up the query for this argument.
	pre_query ()
	Run before the view is built.
	construct ()
	Constructor.
	init (&$view, &$options)
	init the handler with necessary data.
	set_breadcrumb (&$breadcrumb)
	Give an argument the opportunity to modify the breadcrumb, if it wants.
	uses_breadcrumb ()
	Determine if the argument can generate a breadcrumb.
	is_exception ($arg=NULL)
	exception_title ()
	needs_style_plugin ()
	Determine if the argument needs a style plugin.
	option_definition ()
	Information about options for all kinds of purposes will be held here.
	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.
	default_actions ($which=NULL)
	Provide a list of default behaviors for this argument if the argument is not present.
	default_argument_form (&$form, &$form_state)
	Provide a form for selecting the default argument when the default action is set to provide default argument.
	default_summary_form (&$form, &$form_state)
	Provide a form for selecting further summary options when the default action is set to display one.
	default_action ($info=NULL)
	Handle the default action, which means our argument wasn't present.
	validate_fail ()
	How to act if validation failes.
	default_ignore ()
	Default action: ignore.
	default_not_found ()
	Default action: not found.
	default_empty ()
	Default action: empty.
	default_default ()
	This just returns true.
	has_default_argument ()
	Determine if the argument is set to provide a default argument.
	get_default_argument ()
	Get a default argument, if available.
	process_summary_arguments (&$args)
	Process the summary arguments for display.
	default_summary ()
	Default action: summary.
	summary_query ()
	Build the info for the summary query.
	summary_name_field ()
	Add the name field, which is the field displayed in summary queries.
	summary_basics ($count_field=TRUE)
	Some basic summary behavior that doesn't need to be repeated as much as code that goes into summary_query().
	summary_sort ($order, $by=NULL)
	Sorts the summary based upon the user's selection.
	summary_argument ($data)
	Provide the argument to use to link from the summary to the next level; this will be called once per row of a summary, and used as part of $view->get_url().
	summary_name ($data)
	Provides the name to use for the summary.
	title ()
	Get the title this argument will assign the view, given the argument.
	get_title ()
	Called by the view object to get the title.
	validate_arg ($arg)
	Validate that this argument works.
	validate_argument ($arg)
	Called by the menu system to validate an argument.
	validate_argument_basic ($arg)
	Provide a basic argument validation.
	set_argument ($arg)
	Set the input for this argument.
	get_value ()
	Get the value of this argument.
	export_summary ($indent, $prefix, $storage, $option, $definition, $parents)
	Export handler for summary export.
	export_validation ($indent, $prefix, $storage, $option, $definition, $parents)
	Export handler for validation export.
	export_plugin ($indent, $prefix, $storage, $option, $definition, $parents)
	Generic plugin export handler.
	get_plugin ($type= 'argument default', $name=NULL)
	Get the display or row plugin, if it exists.
	get_sort_name ()
	Return a description of how the argument would normally be sorted.
	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.
	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.
	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.
	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
	$validator = NULL
	$argument = NULL
	$value = NULL
	$name_table
	$name_field
	$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

Argument handler for to modify depth for a previous term.

This handler is actually part of the node table and has some restrictions, because it uses a subquery to find nodes with.

Definition at line 11 of file views_handler_argument_term_node_tid_depth_modifier.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_handler_argument::construct ( ) [inherited]

Constructor.

Reimplemented from views_object.

Reimplemented in views_handler_argument_formula, views_handler_argument_locale_group, views_handler_argument_locale_language, views_handler_argument_node_created_fulldate, views_handler_argument_node_created_year, views_handler_argument_node_created_year_month, views_handler_argument_node_created_month, views_handler_argument_node_created_day, views_handler_argument_node_created_week, views_handler_argument_node_language, and views_handler_argument_node_type.

Definition at line 54 of file views_handler_argument.inc.

                       {
    parent::construct();

    if (!empty($this->definition['name field'])) {
      $this->name_field = $this->definition['name field'];
    }
    if (!empty($this->definition['name table'])) {
      $this->name_table = $this->definition['name table'];
    }
  }

views_handler_argument::default_action ( $ info = NULL ) [inherited]

Handle the default action, which means our argument wasn't present.

Override this method only with extreme care.

Returns:: A boolean value; if TRUE, continue building this view. If FALSE, building the view will be aborted here.

Definition at line 663 of file views_handler_argument.inc.

References views_handler_argument::default_actions(), and views_object::options().

Referenced by views_handler_argument::validate_fail().

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

    if (!$info) {
      return FALSE;
    }

    if (!empty($info['method args'])) {
      return call_user_func_array(array(&$this, $info['method']), $info['method args']);
    }
    else {
      return $this->{$info['method']}();
    }
  }

views_handler_argument::default_actions ( $ which = NULL ) [inherited]

Provide a list of default behaviors for this argument if the argument is not present.

Override this method to provide additional (or fewer) default behaviors.

Reimplemented in views_handler_argument_null, views_handler_argument_comment_user_uid, and views_handler_argument_term_node_tid_depth.

Definition at line 478 of file views_handler_argument.inc.

Referenced by views_handler_argument::default_action(), views_handler_argument::has_default_argument(), views_handler_argument::needs_style_plugin(), views_handler_argument::options_form(), views_handler_argument::uses_breadcrumb(), and views_handler_argument::validate_fail().

                                          {
    $defaults = array(
      'ignore' => array(
        'title' => t('Display all results for the specified field'),
        'method' => 'default_ignore',
        'breadcrumb' => TRUE, // generate a breadcrumb to here
      ),
      'default' => array(
        'title' => t('Provide default value'),
        'method' => 'default_default',
        'form method' => 'default_argument_form',
        'has default argument' => TRUE,
        'default only' => TRUE, // this can only be used for missing argument, not validation failure
        'breadcrumb' => TRUE, // generate a breadcrumb to here
      ),
      'not found' => array(
        'title' => t('Hide view'),
        'method' => 'default_not_found',
        'hard fail' => TRUE, // This is a hard fail condition
      ),
      'summary' => array(
        'title' => t('Display a summary'),
        'method' => 'default_summary',
        'form method' => 'default_summary_form',
        'style plugin' => TRUE,
        'breadcrumb' => TRUE, // generate a breadcrumb to here
      ),
      'empty' => array(
        'title' => t('Display contents of "No results found"'),
        'method' => 'default_empty',
        'breadcrumb' => TRUE, // generate a breadcrumb to here
      ),
    );

    if ($this->view->display_handler->has_path()) {
      $defaults['not found']['title'] = t('Show "Page not found"');
    }

    if ($which) {
      if (!empty($defaults[$which])) {
        return $defaults[$which];
      }
    }
    else {
      return $defaults;
    }
  }

views_handler_argument::default_argument_form	(	&$	form,
		&$	form_state
	)			`[inherited]`

Provide a form for selecting the default argument when the default action is set to provide default argument.

Reimplemented in views_handler_argument_date.

Definition at line 530 of file views_handler_argument.inc.

References views_object::$options, views_handler_argument::get_plugin(), views_object::options(), and views_fetch_plugin_data().

                                                       {
    $plugins = views_fetch_plugin_data('argument default');
    $options = array();

    $form['default_argument_skip_url'] = array(
      '#type' => 'checkbox',
      '#title' => t('Skip default argument for view URL'),
      '#default_value' => $this->options['default_argument_skip_url'],
      '#description' => t('Select whether to include this default argument when constructing the URL for this view. Skipping default arguments is useful e.g. in the case of feeds.')
    );

    $form['default_argument_type'] = array(
      '#prefix' => '<div id="edit-options-default-argument-type-wrapper">',
      '#suffix' => '</div>',
      '#type' => 'select',
      '#id' => 'edit-options-default-argument-type',
      '#title' => t('Type'),
      '#default_value' => $this->options['default_argument_type'],

      '#dependency' => array('radio:options[default_action]' => array('default')),
      // Views custom key, moves this element to the appropriate container
      // under the radio button.
      '#argument_option' => 'default',
    );

    foreach ($plugins as $id => $info) {
      if (!empty($info['no ui'])) {
        continue;
      }
      $plugin = $this->get_plugin('argument default', $id);
      if ($plugin) {
        if ($plugin->access() || $this->options['default_argument_type'] == $id) {
          $form['argument_default']['#argument_option'] = 'default';
          $form['argument_default'][$id] = array(
            '#prefix' => '<div id="edit-options-argument-default-options-' . $id . '-wrapper">',
            '#suffix' => '</div>',
            '#id' => 'edit-options-argument-default-options-' . $id,
            '#type' => 'item',
            '#dependency' => array(
              'radio:options[default_action]' => array('default'),
              'edit-options-default-argument-type' => array($id)
            ),
            '#dependency_count' => 2,
          );
          $options[$id] = $info['title'];
          $plugin->options_form($form['argument_default'][$id], $form_state);
        }
      }
    }

    asort($options);
    $form['default_argument_type']['#options'] = $options;
  }

views_handler_argument::default_default ( ) [inherited]

This just returns true.

The view argument builder will know where to find the argument from.

Definition at line 727 of file views_handler_argument.inc.

                             {
    return TRUE;
  }

views_handler_argument::default_empty ( ) [inherited]

Default action: empty.

If an argument was expected and was not given, in this case, display the view's empty text

Definition at line 715 of file views_handler_argument.inc.

                           {
    // We return with no query; this will force the empty text.
    $this->view->built = TRUE;
    $this->view->executed = TRUE;
    $this->view->result = array();
    return FALSE;
  }

views_handler_argument::default_ignore ( ) [inherited]

Default action: ignore.

If an argument was expected and was not given, in this case, simply ignore the argument entirely.

Definition at line 693 of file views_handler_argument.inc.

                            {
    return TRUE;
  }

views_handler_argument::default_not_found ( ) [inherited]

Default action: not found.

If an argument was expected and was not given, in this case, report the view as 'not found' or hide it.

Definition at line 703 of file views_handler_argument.inc.

                               {
    // Set a failure condition and let the display manager handle it.
    $this->view->build_info['fail'] = TRUE;
    return FALSE;
  }

views_handler_argument::default_summary ( ) [inherited]

Default action: summary.

If an argument was expected and was not given, in this case, display a summary query.

Definition at line 769 of file views_handler_argument.inc.

References views_object::options(), views_handler_argument::query(), views_handler_argument::summary_query(), and views_handler_argument::summary_sort().

                             {
    $this->view->build_info['summary'] = TRUE;
    $this->view->build_info['summary_level'] = $this->options['id'];

    // Change the display style to the summary style for this
    // argument.
    $this->view->plugin_name = $this->options['summary']['format'];
    $this->view->style_options = $this->options['summary_options'];

    // Clear out the normal primary field and whatever else may have
    // been added and let the summary do the work.
    $this->query->clear_fields();
    $this->summary_query();

    $by = $this->options['summary']['number_of_records'] ? 'num_records' : NULL;
    $this->summary_sort($this->options['summary']['sort_order'], $by);

    // Summaries have their own sorting and fields, so tell the View not
    // to build these.
    $this->view->build_sort = $this->view->build_fields = FALSE;
    return TRUE;
  }

views_handler_argument::default_summary_form	(	&$	form,
		&$	form_state
	)			`[inherited]`

Provide a form for selecting further summary options when the default action is set to display one.

Definition at line 588 of file views_handler_argument.inc.

References views_object::$options, views_handler_argument::get_plugin(), views_handler_argument::get_sort_name(), views_object::options(), and views_fetch_plugin_data().

                                                      {
    $style_plugins = views_fetch_plugin_data('style');
    $summary_plugins = array();
    $format_options = array();
    foreach ($style_plugins as $key => $plugin) {
      if (isset($plugin['type']) && $plugin['type'] == 'summary') {
        $summary_plugins[$key] = $plugin;
        $format_options[$key] = $plugin['title'];
      }
    }

    $form['summary'] = array(
      // Views custom key, moves this element to the appropriate container
      // under the radio button.
      '#argument_option' => 'summary',
    );
    $form['summary']['sort_order'] = array(
      '#type' => 'radios',
      '#title' => t('Sort order'),
      '#options' => array('asc' => t('Ascending'), 'desc' => t('Descending')),
      '#default_value' => $this->options['summary']['sort_order'],
      '#dependency' => array('radio:options[default_action]' => array('summary')),
    );
    $form['summary']['number_of_records'] = array(
      '#type' => 'radios',
      '#title' => t('Sort by'),
      '#default_value' => $this->options['summary']['number_of_records'],
      '#options' => array(
        0 => $this->get_sort_name(),
        1 => t('Number of records')
      ),
      '#dependency' => array('radio:options[default_action]' => array('summary')),
    );

    $form['summary']['format'] = array(
      '#type' => 'radios',
      '#title' => t('Format'),
      '#options' => $format_options,
      '#default_value' => $this->options['summary']['format'],
      '#dependency' => array('radio:options[default_action]' => array('summary')),
    );

    foreach ($summary_plugins as $id => $info) {
      if (empty($info['uses options'])) {
        continue;
      }
      $plugin = $this->get_plugin('style', $id);
      if ($plugin) {
        $form['summary']['options'][$id] = array(
          '#prefix' => '<div id="edit-options-summary-options-' . $id . '-wrapper">',
          '#suffix' => '</div>',
          '#id' => 'edit-options-summary-options-' . $id,
          '#type' => 'item',
          '#input' => TRUE, // trick it into checking input to make #process run
          '#dependency' => array(
            'radio:options[default_action]' => array('summary'),
            'radio:options[summary][format]' => array($id),
          ),
          '#dependency_count' => 2,
        );
        $options[$id] = $info['title'];
        $plugin->options_form($form['summary']['options'][$id], $form_state);
      }
    }
  }

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_argument::export_plugin	(	$	indent,
		$	prefix,
		$	storage,
		$	option,
		$	definition,
		$	parents
	)			`[inherited]`

Generic plugin export handler.

Since style and validation plugins have their own export handlers, this one is currently only used for default argument plugins.

Reimplemented in views_handler_argument_date.

Definition at line 1112 of file views_handler_argument.inc.

                                                                                     {
    $output = '';
    if ($option == 'default_argument_type') {
      $type = 'argument default';
      $option_name = 'default_argument_options';
    }

    $plugin = $this->get_plugin($type);
    $name = $this->options[$option];

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

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

    return $output;
  }

views_handler_argument::export_summary	(	$	indent,
		$	prefix,
		$	storage,
		$	option,
		$	definition,
		$	parents
	)			`[inherited]`

Export handler for summary export.

Arguments can have styles for the summary view. This special export handler makes sure this works properly.

Definition at line 1064 of file views_handler_argument.inc.

References views_get_plugin().

                                                                                      {
    $output = '';
    $name = $this->options['summary'][$option];
    $options = $this->options['summary_options'];

    $plugin = views_get_plugin('style', $name);
    if ($plugin) {
      $plugin->init($this->view, $this->view->display_handler->display, $options);
      // Write which plugin to use.
      $output .= $indent . $prefix . "['summary']['$option'] = '$name';\n";

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

    return $output;
  }

views_handler_argument::export_validation	(	$	indent,
		$	prefix,
		$	storage,
		$	option,
		$	definition,
		$	parents
	)			`[inherited]`

Export handler for validation export.

Arguments use validation plugins. This special export handler makes sure this works properly.

Definition at line 1088 of file views_handler_argument.inc.

References views_get_plugin().

                                                                                         {
    $output = '';
    $name = $this->options['validate'][$option];
    $options = $this->options['validate_options'];

    $plugin = views_get_plugin('argument validator', $name);
    if ($plugin) {
      $plugin->init($this->view, $this->display, $options);
      // Write which plugin to use.
      $output .= $indent . $prefix . "['validate']['$option'] = '$name';\n";

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

    return $output;
  }

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

Get a default argument, if available.

Definition at line 742 of file views_handler_argument.inc.

References views_handler_argument::get_plugin().

Referenced by views_handler_argument_date::get_default_argument().

                                  {
    $plugin = $this->get_plugin('argument default');
    if ($plugin) {
      return $plugin->get_argument();
    }
  }

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_argument::get_plugin	(	$	type = `'argument default'`,
		$	name = `NULL`
	)			`[inherited]`

Get the display or row plugin, if it exists.

Definition at line 1136 of file views_handler_argument.inc.

References views_get_plugin().

Referenced by views_handler_argument::default_argument_form(), views_handler_argument::default_summary_form(), views_handler_argument_date::export_plugin(), views_handler_argument::get_default_argument(), views_handler_argument::options_form(), views_handler_argument::options_submit(), views_handler_argument::options_validate(), and views_handler_argument::process_summary_arguments().

                                                                {
    $options = array();
    switch ($type) {
      case 'argument default':
        $plugin_name = $this->options['default_argument_type'];
        $options_name = 'default_argument_options';
        break;
      case 'argument validator':
        $plugin_name = $this->options['validate']['type'];
        $options_name = 'validate_options';
        break;
      case 'style':
        $plugin_name = $this->options['summary']['format'];
        $options_name = 'summary_options';
    }

    if (!$name) {
      $name = $plugin_name;
    }

    // we only fetch the options if we're fetching the plugin actually
    // in use.
    if ($name == $plugin_name) {
      $options = $this->options[$options_name];
    }

    $plugin = views_get_plugin($type, $name);
    if ($plugin) {
      // Style plugins expects different parameters as argument related plugins.
      if ($type == 'style') {
        $plugin->init($this->view, $this->view->display_handler->display, $options);
      }
      else {
        $plugin->init($this->view, $this, $options);
      }
      return $plugin;
    }
  }

views_handler_argument::get_sort_name ( ) [inherited]

Return a description of how the argument would normally be sorted.

Subclasses should override this to specify what the default sort order of their argument is (e.g. alphabetical, numeric, date).

Reimplemented in views_handler_argument_date, views_handler_argument_group_by_numeric, views_handler_argument_numeric, views_handler_argument_string, and views_handler_argument_comment_user_uid.

Definition at line 1181 of file views_handler_argument.inc.

Referenced by views_handler_argument::default_summary_form().

                           {
    return t('Default sort', array(), array('context' => 'Sort order'));
  }

views_handler_argument::get_title ( ) [inherited]

Called by the view object to get the title.

This may be set by a validator so we don't necessarily call through to title().

Definition at line 928 of file views_handler_argument.inc.

                       {
    if (isset($this->validated_title)) {
      return $this->validated_title;
    }
    else {
      return $this->title();
    }
  }

views_handler_argument::get_value ( ) [inherited]

Get the value of this argument.

Definition at line 1021 of file views_handler_argument.inc.

                       {
    // If we already processed this argument, we're done.
    if (isset($this->argument)) {
      return $this->argument;
    }

    // Otherwise, we have to pretend to process ourself to find the value.
    $value = NULL;
    // Find the position of this argument within the view.
    $position = 0;
    foreach ($this->view->argument as $id => $argument) {
      if ($id == $this->options['id']) {
        break;
      }
      $position++;
    }

    $arg = isset($this->view->args[$position]) ? $this->view->args[$position] : NULL;
    $this->position = $position;

    // Clone ourselves so that we don't break things when we're really
    // processing the arguments.
    $argument = clone $this;
    if (!isset($arg) && $argument->has_default_argument()) {
      $arg = $argument->get_default_argument();

      // remember that this argument was computed, not passed on the URL.
      $this->is_default = TRUE;
    }
    // Set the argument, which will also validate that the argument can be set.
    if ($argument->set_argument($arg)) {
      $value = $argument->argument;
    }
    unset($argument);
    return $value;
  }

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

Determine if the argument is set to provide a default argument.

Definition at line 734 of file views_handler_argument.inc.

References views_handler_argument::default_actions(), and views_object::options().

                                  {
    $info = $this->default_actions($this->options['default_action']);
    return !empty($info['has default argument']);
  }

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_argument::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_argument_many_to_one, views_handler_argument_string, and views_handler_argument_field_list.

Definition at line 65 of file views_handler_argument.inc.

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

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

    // Compatibility: The new UI changed several settings.
    if (!empty($options['wildcard']) && !isset($options['exception']['value'])) {
      $this->options['exception']['value'] = $options['wildcard'];
    }
    if (!empty($options['wildcard_substitution']) && !isset($options['exception']['title'])) {
      // Enable the checkbox if the title is filled in.
      $this->options['exception']['title_enable'] = 1;
      $this->options['exception']['title'] = $options['wildcard_substitution'];
    }

    if (!isset($options['summary']['format']) && !empty($options['style_plugin'])) {
      $this->options['summary']['format'] = $options['style_plugin'];
    }

    if (!isset($options['summary']['sort_order']) && !empty($options['default_action']) && $options['default_action'] == 'summary asc') {
      $this->options['default_action'] = 'summary';
      $this->options['summary']['sort_order'] = 'asc';
      $this->options['summary']['number_of_records'] = 0;
      $this->options['summary_options'] = $options['style_options'];
    }
    elseif (!isset($options['summary']['sort_order']) && !empty($options['default_action']) && $options['default_action'] == 'summary desc') {
      $this->options['default_action'] = 'summary';
      $this->options['summary']['sort_order'] = 'desc';
      $this->options['summary']['number_of_records'] = 0;
      $this->options['summary_options'] = $options['style_options'];
    }
    elseif (!isset($options['summary']['sort_order']) && !empty($options['default_action']) && $options['default_action'] == 'summary asc by count') {
      $this->options['default_action'] = 'summary';
      $this->options['summary']['sort_order'] = 'asc';
      $this->options['summary']['number_of_records'] = 1;
      $this->options['summary_options'] = $options['style_options'];
    }
    elseif (!isset($options['summary']['sort_order']) && !empty($options['default_action']) && $options['default_action'] == 'summary desc by count') {
      $this->options['default_action'] = 'summary';
      $this->options['summary']['sort_order'] = 'desc';
      $this->options['summary']['number_of_records'] = 1;
      $this->options['summary_options'] = $options['style_options'];
    }

    if (!empty($options['title']) && !isset($options['title_enable'])) {
      $this->options['title_enable'] = 1;
    }
    if (!empty($options['breadcrumb']) && !isset($options['breadcrumb_enable'])) {
      $this->options['breadcrumb_enable'] = 1;
    }

    if (!empty($options['validate_type']) && !isset($options['validate']['type'])) {
      $this->options['validate']['type'] = $options['validate_type'];
      $this->options['specify_validation'] = 1;
    }
    if (!empty($options['validate_fail']) && !isset($options['validate']['fail'])) {
      $this->options['validate']['fail'] = $options['validate_fail'];
      $this->options['specify_validation'] = 1;
    }
  }

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

Determine if the argument needs a style plugin.

Returns:: TRUE/FALSE

Reimplemented from views_handler.

Definition at line 163 of file views_handler_argument.inc.

References views_handler_argument::default_actions(), and views_object::options().

                                {
    $info = $this->default_actions($this->options['default_action']);
    $validate_info = $this->default_actions($this->options['validate']['fail']);
    return !empty($info['style plugin']) || !empty($validate_info['style plugin']);
  }

views_handler_argument::option_definition ( ) [inherited]

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.

Reimplemented in views_handler_argument_many_to_one, views_handler_argument_null, views_handler_argument_numeric, views_handler_argument_string, views_handler_argument_field_list, views_handler_argument_term_node_tid, and views_handler_argument_term_node_tid_depth.

Definition at line 169 of file views_handler_argument.inc.

References views_object::$options.

                               {
    $options = parent::option_definition();

    $options['default_action'] = array('default' => 'ignore');
    $options['exception'] = array(
      'contains' => array(
        'value' => array('default' => 'all'),
        'title_enable' => array('default' => 0),
        'title' => array('default' => t('All'), 'translatable' => TRUE),
      ),
    );
    $options['title_enable'] = array('default' => 0);
    $options['title'] = array('default' => '', 'translatable' => TRUE);
    $options['breadcrumb_enable'] = array('default' => 0);
    $options['breadcrumb'] = array('default' => '', 'translatable' => TRUE);
    $options['default_argument_type'] = array('default' => 'fixed', 'export' => 'export_plugin');
    $options['default_argument_options'] = array('default' => array(), 'export' => FALSE);
    $options['default_argument_skip_url'] = array('default' => FALSE);
    $options['summary_options'] = array('default' => array(), 'export' => FALSE);
    $options['summary'] = array(
      'contains' => array(
        'sort_order' => array('default' => 'asc'),
        'number_of_records' => array('default' => 0),
        'format' => array('default' => 'default_summary', 'export' => 'export_summary'),
      ),
    );
    $options['specify_validation'] = array('default' => 0);
    $options['validate'] = array(
      'contains' => array(
        'type' => array('default' => 'none', 'export' => 'export_validation'),
        'fail' => array('default' => 'not found'),
      ),
    );
    $options['validate_options'] = array('default' => array(), 'export' => FALSE);

    return $options;
  }

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

Set default options on this object.

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

Reimplemented in views_plugin_style_default.

Definition at line 60 of file base.inc.

{ }

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

Build the options form.

Reimplemented from views_handler_argument.

Definition at line 12 of file views_handler_argument_term_node_tid_depth_modifier.inc.

{ }

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

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

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

Reimplemented from views_handler.

Definition at line 431 of file views_handler_argument.inc.

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

                                                {
    if (empty($form_state['values']['options'])) {
      return;
    }

    // Let the plugins make submit modifications if necessary.
    $default_id = $form_state['values']['options']['default_argument_type'];
    $plugin = $this->get_plugin('argument default', $default_id);
    if ($plugin) {
      $options = &$form_state['values']['options']['argument_default'][$default_id];
      $plugin->options_submit($form['argument_default'][$default_id], $form_state, $options);
      // Copy the now submitted options to their final resting place so they get saved.
      $form_state['values']['options']['default_argument_options'] = $options;
    }

    // summary plugin
    $summary_id = $form_state['values']['options']['summary']['format'];
    $plugin = $this->get_plugin('style', $summary_id);
    if ($plugin) {
      $options = &$form_state['values']['options']['summary']['options'][$summary_id];
      $plugin->options_submit($form['summary']['options'][$summary_id], $form_state, $options);
      // Copy the now submitted options to their final resting place so they get saved.
      $form_state['values']['options']['summary_options'] = $options;
    }

    $validate_id = $form_state['values']['options']['validate']['type'];
    $plugin = $this->get_plugin('argument validator', $validate_id);
    if ($plugin) {
      $options = &$form_state['values']['options']['validate']['options'][$validate_id];
      $plugin->options_submit($form['validate']['options'][$validate_id], $form_state, $options);
      // Copy the now submitted options to their final resting place so they get saved.
      $form_state['values']['options']['validate_options'] = $options;
    }

    // Clear out the content of title if it's not enabled.
    $options =& $form_state['values']['options'];
    if (empty($options['title_enable'])) {
      $options['title'] = '';
    }
  }

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

Validate the options form.

Reimplemented from views_handler.

Definition at line 404 of file views_handler_argument.inc.

References views_handler_argument::get_plugin().

                                                  {
    if (empty($form_state['values']['options'])) {
      return;
    }

    // Let the plugins do validation.
    $default_id = $form_state['values']['options']['default_argument_type'];
    $plugin = $this->get_plugin('argument default', $default_id);
    if ($plugin) {
      $plugin->options_validate($form['argument_default'][$default_id], $form_state, $form_state['values']['options']['argument_default'][$default_id]);
    }

    // summary plugin
    $summary_id = $form_state['values']['options']['summary']['format'];
    $plugin = $this->get_plugin('style', $summary_id);
    if ($plugin) {
      $plugin->options_validate($form['summary']['options'][$summary_id], $form_state, $form_state['values']['options']['summary']['options'][$summary_id]);
    }

    $validate_id = $form_state['values']['options']['validate']['type'];
    $plugin = $this->get_plugin('argument validator', $validate_id);
    if ($plugin) {
      $plugin->options_validate($form['validate']['options'][$default_id], $form_state, $form_state['values']['options']['validate']['options'][$validate_id]);
    }

  }

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_argument_term_node_tid_depth_modifier::pre_query ( )

Run before the view is built.

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

Reimplemented from views_handler.

Definition at line 14 of file views_handler_argument_term_node_tid_depth_modifier.inc.

References views_object::options().

                       {
    // We don't know our argument yet, but it's based upon our position:
    $argument = isset($this->view->args[$this->position]) ? $this->view->args[$this->position] : NULL;
    if (!is_numeric($argument)) {
      return;
    }

    if ($argument > 10) {
      $argument = 10;
    }

    if ($argument < -10) {
      $argument = -10;
    }

    // figure out which argument preceded us.
    $keys = array_reverse(array_keys($this->view->argument));
    $skip = TRUE;
    foreach ($keys as $key) {
      if ($key == $this->options['id']) {
        $skip = FALSE;
        continue;
      }

      if ($skip) {
        continue;
      }

      if (empty($this->view->argument[$key])) {
        continue;
      }

      if (isset($handler)) {
        unset($handler);
      }

      $handler = &$this->view->argument[$key];
      if (empty($handler->definition['accept depth modifier'])) {
        continue;
      }

      // Finally!
      $handler->options['depth'] = $argument;
    }
  }

views_handler_argument::process_summary_arguments ( &$ args ) [inherited]

Process the summary arguments for display.

For example, the validation plugin may want to alter an argument for use in the URL.

Definition at line 755 of file views_handler_argument.inc.

References views_handler_argument::get_plugin(), and views_object::options().

                                             {
    if ($this->options['validate']['type'] != 'none') {
      if (isset($this->validator) || $this->validator = $this->get_plugin('argument validator')) {
        $this->validator->process_summary_arguments($args);
      }
    }
  }

views_handler_argument_term_node_tid_depth_modifier::query ( $ group_by = FALSE )

Set up the query for this argument.

The argument sent may be found at $this->argument.

Reimplemented from views_handler_argument.

Definition at line 13 of file views_handler_argument_term_node_tid_depth_modifier.inc.

{ }

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_handler_argument::set_argument ( $ arg ) [inherited]

Set the input for this argument.

Returns:: TRUE if it successfully validates; FALSE if it does not.

Definition at line 1013 of file views_handler_argument.inc.

                              {
    $this->argument = $arg;
    return $this->validate_arg($arg);
  }

views_handler_argument::set_breadcrumb ( &$ breadcrumb ) [inherited]

Give an argument the opportunity to modify the breadcrumb, if it wants.

This only gets called on displays where a breadcrumb is actually used.

The breadcrumb will be in the form of an array, with the keys being the path and the value being the already sanitized title of the path.

Reimplemented in views_handler_argument_term_node_tid, and views_handler_argument_term_node_tid_depth.

Definition at line 131 of file views_handler_argument.inc.

{ }

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_argument::summary_argument ( $ data ) [inherited]

Provide the argument to use to link from the summary to the next level; this will be called once per row of a summary, and used as part of $view->get_url().

Parameters:

$data

The query results for the row.

Reimplemented in views_handler_argument_many_to_one, views_handler_argument_string, views_handler_argument_node_created_month, and views_handler_argument_node_created_day.

Definition at line 886 of file views_handler_argument.inc.

                                   {
    return $data->{$this->base_alias};
  }

views_handler_argument::summary_basics ( $ count_field = TRUE ) [inherited]

Some basic summary behavior that doesn't need to be repeated as much as code that goes into summary_query().

Definition at line 852 of file views_handler_argument.inc.

References views_handler_argument::query().

Referenced by views_handler_argument_string::summary_query(), views_handler_argument_many_to_one::summary_query(), views_handler_argument_formula::summary_query(), and views_handler_argument::summary_query().

                                               {
    // Add the number of nodes counter
    $distinct = ($this->view->display_handler->get_option('distinct') && empty($this->query->no_distinct));

    $count_alias = $this->query->add_field($this->query->base_table, $this->query->base_field, 'num_records',
                                           array('count' => TRUE, 'distinct' => $distinct));
    $this->query->add_groupby($this->name_alias);

    if ($count_field) {
      $this->query->set_count_field($this->table_alias, $this->real_field);
    }

    $this->count_alias = $count_alias;
  }

views_handler_argument::summary_name ( $ data ) [inherited]

Provides the name to use for the summary.

By default this is just the name field.

Parameters:

$data

The query results for the row.

Reimplemented in views_handler_argument_string, views_handler_argument_field_list, views_handler_argument_locale_group, views_handler_argument_locale_language, views_handler_argument_node_created_fulldate, views_handler_argument_node_created_year_month, views_handler_argument_node_created_month, views_handler_argument_node_created_day, views_handler_argument_node_created_week, views_handler_argument_node_language, and views_handler_argument_node_type.

Definition at line 897 of file views_handler_argument.inc.

                               {
    $value = $data->{$this->name_alias};
    if (empty($value) && !empty($this->definition['empty field name'])) {
      $value = $this->definition['empty field name'];
    }
    return check_plain($value);
  }

views_handler_argument::summary_name_field ( ) [inherited]

Add the name field, which is the field displayed in summary queries.

This is often used when the argument is numeric.

Definition at line 817 of file views_handler_argument.inc.

References views_handler_argument::query(), and views_get_table_join().

Referenced by views_handler_argument_string::summary_query(), views_handler_argument_many_to_one::summary_query(), and views_handler_argument::summary_query().

                                {
    // Add the 'name' field. For example, if this is a uid argument, the
    // name field would be 'name' (i.e, the username).

    if (isset($this->name_table)) {
      // if the alias is different then we're probably added, not ensured,
      // so look up the join and add it instead.
      if ($this->table_alias != $this->name_table) {
        $j = views_get_table_join($this->name_table, $this->table);
        if ($j) {
          $join = clone $j;
          $join->left_table = $this->table_alias;
          $this->name_table_alias = $this->query->add_table($this->name_table, $this->relationship, $join);
        }
      }
      else {
        $this->name_table_alias = $this->query->ensure_table($this->name_table, $this->relationship);
      }
    }
    else {
      $this->name_table_alias = $this->table_alias;
    }

    if (isset($this->name_field)) {
      $this->name_alias = $this->query->add_field($this->name_table_alias, $this->name_field);
    }
    else {
      $this->name_alias = $this->base_alias;
    }
  }

views_handler_argument::summary_query ( ) [inherited]

Build the info for the summary query.

This must:

add_groupby: group on this field in order to create summaries.
add_field: add a 'num_nodes' field for the count. Usually it will be a count on $view->base_field
set_count_field: Reset the count field so we get the right paging.

Returns:: The alias used to get the number of records (count) for this entry.

Reimplemented in views_handler_argument_formula, views_handler_argument_many_to_one, and views_handler_argument_string.

Definition at line 804 of file views_handler_argument.inc.

References views_handler::ensure_my_table(), views_handler_argument::query(), views_handler_argument::summary_basics(), and views_handler_argument::summary_name_field().

Referenced by views_handler_argument::default_summary().

                           {
    $this->ensure_my_table();
    // Add the field.
    $this->base_alias = $this->query->add_field($this->table_alias, $this->real_field);

    $this->summary_name_field();
    return $this->summary_basics();
  }

views_handler_argument::summary_sort	(	$	order,
		$	by = `NULL`
	)			`[inherited]`

Sorts the summary based upon the user's selection.

The base variant of this is usually adequte.

Parameters:

$order

The order selected in the UI.

Definition at line 874 of file views_handler_argument.inc.

References views_handler_argument::query().

Referenced by views_handler_argument::default_summary().

                                            {
    $this->query->add_orderby(NULL, NULL, $order, (!empty($by) ? $by : $this->name_alias));
  }

views_handler_argument::title ( ) [inherited]

Get the title this argument will assign the view, given the argument.

This usually needs to be overridden to provide a proper title.

Definition at line 920 of file views_handler_argument.inc.

                   {
    return check_plain($this->argument);
  }

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

Determine if the argument can generate a breadcrumb.

Returns:: TRUE/FALSE

Definition at line 138 of file views_handler_argument.inc.

References views_handler_argument::default_actions(), and views_object::options().

                             {
    $info = $this->default_actions($this->options['default_action']);
    return !empty($info['breadcrumb']);
  }

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

views_handler_argument::validate_arg ( $ arg ) [inherited]

Validate that this argument works.

By default, all arguments are valid.

Definition at line 940 of file views_handler_argument.inc.

                              {
    // By using % in URLs, arguments could be validated twice; this eases
    // that pain.
    if (isset($this->argument_validated)) {
      return $this->argument_validated;
    }

    if ($this->is_exception($arg)) {
      return $this->argument_validated = TRUE;
    }

    if ($this->options['validate']['type'] == 'none') {
      return $this->argument_validated = $this->validate_argument_basic($arg);
    }

    $plugin = $this->get_plugin('argument validator');
    if ($plugin) {
      return $this->argument_validated = $plugin->validate_argument($arg);
    }

    // If the plugin isn't found, fall back to the basic validation path:
    return $this->argument_validated = $this->validate_argument_basic($arg);
  }

views_handler_argument::validate_argument ( $ arg ) [inherited]

Called by the menu system to validate an argument.

This checks to see if this is a 'soft fail', which means that if the argument fails to validate, but there is an action to take anyway, then validation cannot actually fail.

Definition at line 971 of file views_handler_argument.inc.

                                   {
    $validate_info = $this->default_actions($this->options['validate']['fail']);
    if (empty($validate_info['hard fail'])) {
      return TRUE;
    }

    $rc = $this->validate_arg($arg);

    // If the validator has changed the validate fail condition to a
    // soft fail, deal with that:
    $validate_info = $this->default_actions($this->options['validate']['fail']);
    if (empty($validate_info['hard fail'])) {
      return TRUE;
    }

    return $rc;
  }

views_handler_argument::validate_argument_basic ( $ arg ) [inherited]

Provide a basic argument validation.

This can be overridden for more complex types; the basic validator only checks to see if the argument is not NULL or is numeric if the definition says it's numeric.

Reimplemented in views_handler_argument_null.

Definition at line 996 of file views_handler_argument.inc.

                                         {
    if (!isset($arg) || $arg === '') {
      return FALSE;
    }

    if (!empty($this->definition['numeric']) && !isset($this->options['break_phrase']) && !is_numeric($arg)) {
      return FALSE;
    }

    return TRUE;
  }

views_handler_argument::validate_fail ( ) [inherited]

How to act if validation failes.

Definition at line 683 of file views_handler_argument.inc.

References views_handler_argument::default_action(), views_handler_argument::default_actions(), and views_object::options().

                           {
    $info = $this->default_actions($this->options['validate']['fail']);
    return $this->default_action($info);
  }

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/taxonomy/views_handler_argument_term_node_tid_depth_modifier.inc

views_handler_argument_term_node_tid_depth_modifier Class Reference [Handlers for arguments]

Public Member Functions

Public Attributes

Detailed Description

Member Function Documentation

Member Data Documentation

views_handler_argument_term_node_tid_depth_modifier Class Reference
[Handlers for arguments]