class views_handler_filter_in_operator in Views (for Drupal 7) 6.3

Same name and namespace in other branches

6.2 handlers/views_handler_filter_in_operator.inc \views_handler_filter_in_operator
7.3 handlers/views_handler_filter_in_operator.inc \views_handler_filter_in_operator

Simple filter to handle matching of multiple options selectable via checkboxes

Definition items:

numeric: If set to true, this item will use numeric operators instead of string.
options callback: The function to call in order to generate the value options. If omitted, the options 'Yes' and 'No' will be used.
options arguments: An array of arguments to pass to the options callback.

Hierarchy

class \views_object
- class \views_handler
  - class \views_handler_filter
    class \views_handler_filter_in_operator

Expanded class hierarchy of views_handler_filter_in_operator

File

handlers/views_handler_filter_in_operator.inc, line 12

View source

class views_handler_filter_in_operator extends views_handler_filter {
  var $value_form_type = 'checkboxes';

  /**
   * @var array
   * Stores all operations which are available on the form.
   */
  var $value_options = NULL;
  function construct() {
    parent::construct();
    $this->value_title = t('Options');
    $this->value_options = NULL;
  }

  /**
   * Child classes should be used to override this function and set the
   * 'value options', unless 'options callback' is defined as a valid function
   * or static public method to generate these values.
   *
   * This can use a guard to be used to reduce database hits as much as
   * possible.
   *
   * @return
   *   Return the stored values in $this->value_options if someone expects it.
   */
  function get_value_options() {
    if (isset($this->value_options)) {
      return;
    }
    if (isset($this->definition['options callback']) && is_callable($this->definition['options callback'])) {
      if (isset($this->definition['options arguments']) && is_array($this->definition['options arguments'])) {
        $this->value_options = call_user_func_array($this->definition['options callback'], $this->definition['options arguments']);
      }
      else {
        $this->value_options = call_user_func($this->definition['options callback']);
      }
    }
    else {
      $this->value_options = array(
        t('Yes'),
        t('No'),
      );
    }
    return $this->value_options;
  }
  function expose_options() {
    parent::expose_options();
    $this->options['expose']['reduce'] = FALSE;
  }
  function expose_form_right(&$form, &$form_state) {
    parent::expose_form_right($form, $form_state);
    $form['expose']['reduce'] = array(
      '#type' => 'checkbox',
      '#title' => t('Limit list to selected items'),
      '#description' => t('If checked, the only items presented to the user will be the ones selected here.'),
      '#default_value' => !empty($this->options['expose']['reduce']),
    );
  }
  function option_definition() {
    $options = parent::option_definition();
    $options['operator']['default'] = 'in';
    $options['value']['default'] = array();
    $options['expose']['contains']['reduce'] = array(
      'default' => FALSE,
    );
    return $options;
  }

  /**
   * This kind of construct makes it relatively easy for a child class
   * to add or remove functionality by overriding this function and
   * adding/removing items from this array.
   */
  function operators() {
    $operators = array(
      'in' => array(
        'title' => t('Is one of'),
        'short' => t('in'),
        'short_single' => t('='),
        'method' => 'op_simple',
        'values' => 1,
      ),
      'not in' => array(
        'title' => t('Is not one of'),
        'short' => t('not in'),
        'short_single' => t('<>'),
        'method' => 'op_simple',
        'values' => 1,
      ),
    );

    // if the definition allows for the empty operator, add it.
    if (!empty($this->definition['allow empty'])) {
      $operators += array(
        'empty' => array(
          'title' => t('Is empty (NULL)'),
          'method' => 'op_empty',
          'short' => t('empty'),
          'values' => 0,
        ),
        'not empty' => array(
          'title' => t('Is not empty (NOT NULL)'),
          'method' => 'op_empty',
          'short' => t('not empty'),
          'values' => 0,
        ),
      );
    }
    return $operators;
  }

  /**
   * Build strings from the operators() for 'select' options
   */
  function operator_options($which = 'title') {
    $options = array();
    foreach ($this
      ->operators() as $id => $info) {
      $options[$id] = $info[$which];
    }
    return $options;
  }
  function operator_values($values = 1) {
    $options = array();
    foreach ($this
      ->operators() as $id => $info) {
      if (isset($info['values']) && $info['values'] == $values) {
        $options[] = $id;
      }
    }
    return $options;
  }
  function value_form(&$form, &$form_state) {
    $form['value'] = array();
    $this
      ->get_value_options();
    $options = $this->value_options;
    $default_value = (array) $this->value;
    $which = 'all';
    if (!empty($form['operator'])) {
      $source = $form['operator']['#type'] == 'radios' ? 'radio:options[operator]' : 'edit-options-operator';
    }
    if (!empty($form_state['exposed'])) {
      $identifier = $this->options['expose']['identifier'];
      if (empty($this->options['expose']['use_operator']) || empty($this->options['expose']['operator'])) {

        // exposed and locked.
        $which = in_array($this->operator, $this
          ->operator_values(1)) ? 'value' : 'none';
      }
      else {
        $source = 'edit-' . form_clean_id($this->options['expose']['operator']);
      }
      if (!empty($this->options['expose']['reduce'])) {
        $options = $this
          ->reduce_value_options();
        if (empty($this->options['expose']['single']) && !empty($this->options['expose']['optional'])) {
          $default_value = array();
        }
      }
      if (!empty($this->options['expose']['single'])) {
        if (!empty($this->options['expose']['optional']) && (empty($default_value) || !empty($this->options['expose']['reduce']))) {
          $default_value = 'All';
        }
        else {
          if (empty($default_value)) {
            $keys = array_keys($options);
            $default_value = array_shift($keys);
          }
          else {
            $copy = $default_value;
            $default_value = array_shift($copy);
          }
        }
      }
    }
    if ($which == 'all' || $which == 'value') {
      $form['value'] = array(
        '#type' => $this->value_form_type,
        '#title' => $this->value_title,
        '#options' => $options,
        '#default_value' => $default_value,
        // These are only valid for 'select' type, but do no harm to checkboxes.
        '#multiple' => TRUE,
        '#size' => count($options) > 8 ? 8 : count($options),
      );
      if (!empty($form_state['exposed']) && !isset($form_state['input'][$identifier])) {
        $form_state['input'][$identifier] = $default_value;
      }
      $process = array();
      if ($this->value_form_type == 'checkboxes') {

        // If this form element will use checkboxes in the UI, we need to
        // check_plain() all the options ourselves since FAPI is inconsistent
        // about this. However, instead of directly doing that to the #options
        // right now, we define a #process callback since we might change our
        // mind later and convert this into a 'select' form element, which
        // would lead to double-escaping the options.
        $process[] = 'views_process_check_options';
      }
      if ($which == 'all') {
        if (empty($form_state['exposed']) && ($this->value_form_type == 'checkboxes' || $this->value_form_type == 'radios')) {
          $process[] = "expand_{$this->value_form_type}";
          $form['value']['#prefix'] = '<div id="edit-options-value-wrapper">';
          $form['value']['#suffix'] = '</div>';
        }
        $process[] = 'views_process_dependency';
        $form['value']['#dependency'] = array(
          $source => $this
            ->operator_values(1),
        );
      }
      if (!empty($process)) {
        $form['value']['#process'] = $process;
      }
    }
  }

  /**
   * When using exposed filters, we may be required to reduce the set.
   */
  function reduce_value_options($input = NULL) {
    if (!isset($input)) {
      $input = $this->value_options;
    }

    // Because options may be an array of strings, or an array of mixed arrays
    // and strings (optgroups) or an array of objects, we have to
    // step through and handle each one individually.
    $options = array();
    foreach ($input as $id => $option) {
      if (is_array($option)) {
        $options[$id] = $this
          ->reduce_value_options($option);
        continue;
      }
      else {
        if (is_object($option)) {
          $keys = array_keys($option->option);
          $key = array_shift($keys);
          if (isset($this->options['value'][$key])) {
            $options[$id] = $option;
          }
        }
        else {
          if (isset($this->options['value'][$id])) {
            $options[$id] = $option;
          }
        }
      }
    }
    return $options;
  }
  function accept_exposed_input($input) {

    // A very special override because the All state for this type of
    // filter could have a default:
    if (empty($this->options['exposed'])) {
      return TRUE;
    }

    // If this is single and optional, this says that yes this filter will
    // participate, but using the default settings, *if* 'limit is true.
    if (!empty($this->options['expose']['single']) && !empty($this->options['expose']['optional']) && !empty($this->options['expose']['limit'])) {
      $identifier = $this->options['expose']['identifier'];
      if ($input[$identifier] == 'All') {
        return TRUE;
      }
    }
    return parent::accept_exposed_input($input);
  }
  function value_submit($form, &$form_state) {

    // Drupal's FAPI system automatically puts '0' in for any checkbox that
    // was not set, and the key to the checkbox if it is set.
    // Unfortunately, this means that if the key to that checkbox is 0,
    // we are unable to tell if that checkbox was set or not.
    // Luckily, the '#value' on the checkboxes form actually contains
    // *only* a list of checkboxes that were set, and we can use that
    // instead.
    $form_state['values']['options']['value'] = $form['value']['#value'];
  }
  function admin_summary() {
    if (!empty($this->options['exposed'])) {
      return t('exposed');
    }
    $info = $this
      ->operators();
    $this
      ->get_value_options();
    if (!is_array($this->value)) {
      return;
    }
    $operator = check_plain($info[$this->operator]['short']);
    $values = '';
    if (in_array($this->operator, $this
      ->operator_values(1))) {

      // Remove every element which is not known.
      foreach ($this->value as $value) {
        if (!isset($this->value_options[$value])) {
          unset($this->value[$value]);
        }
      }

      // Choose different kind of ouput for 0, a single and multiple values.
      if (count($this->value) == 0) {
        $values = t('Unknown');
      }
      else {
        if (count($this->value) == 1) {

          // If any, use the 'single' short name of the operator instead.
          if (isset($info[$this->operator]['short_single'])) {
            $operator = check_plain($info[$this->operator]['short_single']);
          }
          $keys = $this->value;
          $value = array_shift($keys);
          if (isset($this->value_options[$value])) {
            $values = check_plain($this->value_options[$value]);
          }
          else {
            $values = '';
          }
        }
        else {
          foreach ($this->value as $value) {
            if ($values !== '') {
              $values .= ', ';
            }
            if (strlen($values) > 8) {
              $values .= '...';
              break;
            }
            if (isset($this->value_options[$value])) {
              $values .= check_plain($this->value_options[$value]);
            }
          }
        }
      }
    }
    return $operator . ($values !== '' ? ' ' . $values : '');
  }
  function query() {
    $info = $this
      ->operators();
    if (!empty($info[$this->operator]['method'])) {
      $this
        ->{$info[$this->operator]['method']}();
    }
  }
  function op_simple() {
    if (empty($this->value)) {
      return;
    }
    $this
      ->ensure_my_table();
    $placeholder = !empty($this->definition['numeric']) ? '%d' : "'%s'";
    $replace = array_fill(0, sizeof($this->value), $placeholder);
    $in = ' (' . implode(", ", $replace) . ')';

    // We use array_values() because the checkboxes keep keys and that can cause
    // array addition problems.
    $this->query
      ->add_where($this->options['group'], "{$this->table_alias}.{$this->real_field} " . $this->operator . $in, array_values($this->value));
  }
  function op_empty() {
    $this
      ->ensure_my_table();
    $field = "{$this->table_alias}.{$this->real_field}";
    if ($this->operator == 'empty') {
      $operator = "IS NULL";
    }
    else {
      $operator = "IS NOT NULL";
    }
    $this->query
      ->add_where($this->options['group'], "{$field} {$operator}");
  }
  function validate() {
    $this
      ->get_value_options();
    $errors = array();

    // If the operator is an operator which doesn't require a value, there is
    // no need for additional validation.
    if (in_array($this->operator, $this
      ->operator_values(0))) {
      return array();
    }
    if (!in_array($this->operator, $this
      ->operator_values(1))) {
      $errors[] = t('The operator is invalid on filter: @filter.', array(
        '@filter' => $this
          ->ui_name(TRUE),
      ));
    }
    if (is_array($this->value)) {
      if (!isset($this->value_options)) {

        // Don't validate if there are none value options provided, for example for special handlers.
        return $errors;
      }
      if ($this->options['exposed'] && !$this->options['expose']['required'] && empty($this->value)) {

        // Don't validate if the field is exposed and no default value is provided.
        return $errors;
      }

      // Some filter_in_operator usage uses optgroups forms, so flatten it.
      $flat_options = form_options_flatten($this->value_options, TRUE);

      // Remove every element which is not known.
      foreach ($this->value as $value) {
        if (!isset($flat_options[$value])) {
          unset($this->value[$value]);
        }
      }

      // Choose different kind of ouput for 0, a single and multiple values.
      if (count($this->value) == 0) {
        $errors[] = t('No valid values found on filter: @filter.', array(
          '@filter' => $this
            ->ui_name(TRUE),
        ));
      }
    }
    elseif (!empty($this->value) && ($this->operator == 'in' || $this->operator == 'not in')) {
      $errors[] = t('The value @value is not an array for @operator on filter: @filter', array(
        '@value' => views_var_export($this->value),
        '@operator' => $this->operator,
        '@filter' => $this
          ->ui_name(TRUE),
      ));
    }
    return $errors;
  }

}

Members

Name	Type	Description	Overrides
views_handler::$handler_type	property	The type of the handler, for example filter/footer/field.
views_handler::$query	property	Where the $query object will reside:	6
views_handler::$view	property	The top object of a view. Overrides views_object::$view
views_handler::access	function	Check whether current user has access to this handler.	6
views_handler::broken	function	Determine if the handler is considered 'broken', meaning it's a a placeholder used when a handler can't be found.	6
views_handler::ensure_my_table	function	Ensure the main table for this handler is in the query. This is used a lot.	8
views_handler::exposed_submit	function	Submit the exposed handler form
views_handler::exposed_validate	function	Validate the exposed handler form	4
views_handler::expose_form	function	Overridable form for exposed handler options.
views_handler::expose_submit	function	Perform any necessary changes to the form exposes prior to storage. There is no need for this function to actually store the data.
views_handler::extra_options	function	Provide defaults for the handler.
views_handler::extra_options_form	function	Provide a form for setting options.	1
views_handler::extra_options_submit	function	Perform any necessary changes to the form values prior to storage. There is no need for this function to actually store the data.
views_handler::extra_options_validate	function	Validate the options form.
views_handler::get_field	function	Shortcut to get a handler's raw field value.
views_handler::get_join	function	Get the join object that should be used for this handler.
views_handler::has_extra_options	function	If a handler has 'extra options' it will get a little settings widget and another form called extra_options.	1
views_handler::is_exposed	function	Determine if this item is 'exposed', meaning it provides form elements to let users modify the view.
views_handler::needs_style_plugin	function	Determine if the argument needs a style plugin.	1
views_handler::pre_query	function	Run before the view is built.	1
views_handler::sanitize_value	function	Sanitize the value for output.
views_handler::set_relationship	function	Called just prior to query(), this lets a handler set up any relationship it needs.
views_handler::show_expose_button	function	Shortcut to display the expose/hide button.
views_handler::show_expose_form	function	Shortcut to display the exposed options form.
views_handler::ui_name	function	Return a string representing this handler's name in the UI.	10
views_handler::use_group_by	function	Provides the handler some groupby.	2
views_handler_filter::$operator	property	Contains the operator which is used on the query.
views_handler_filter::$value	property	Contains the actual value of the field,either configured in the views ui or entered in the exposed filters.
views_handler_filter::can_expose	function	Determine if a filter can be exposed. Overrides views_handler::can_expose	3
views_handler_filter::can_group	function	Can this filter be used in OR groups?	2
views_handler_filter::exposed_form	function	Render our chunk of the exposed filter form when selecting Overrides views_handler::exposed_form	1
views_handler_filter::exposed_info	function	Tell the renderer about our exposed form. This only needs to be overridden for particularly complex forms. And maybe not even then. Overrides views_handler::exposed_info
views_handler_filter::exposed_translate	function	Make some translations to a form item to make it more suitable to exposing.
views_handler_filter::expose_form_left	function	Handle the 'left' side fo the exposed options form. Overrides views_handler::expose_form_left
views_handler_filter::expose_validate	function	Validate the options form. Overrides views_handler::expose_validate
views_handler_filter::init	function	Provide some extra help to get the operator/value easier to use. Overrides views_handler::init	1
views_handler_filter::operator_form	function	Provide a form for setting the operator.	6
views_handler_filter::operator_submit	function	Perform any necessary changes to the form values prior to storage. There is no need for this function to actually store the data.
views_handler_filter::operator_validate	function	Validate the operator form.
views_handler_filter::options_form	function	Provide the basic form which calls through to subforms. If overridden, it is best to call through to the parent, or to at least make sure all of the functions in this form are called. Overrides views_handler::options_form	3
views_handler_filter::options_submit	function	Simple submit handler Overrides views_handler::options_submit
views_handler_filter::options_validate	function	Simple validate handler Overrides views_handler::options_validate	1
views_handler_filter::show_operator_form	function	Shortcut to display the operator form.
views_handler_filter::show_value_form	function	Shortcut to display the value form.
views_handler_filter::store_exposed_input	function	If set to remember exposed input in the session, store it there. Overrides views_handler::store_exposed_input
views_handler_filter::value_validate	function	Validate the options form.	3
views_handler_filter_in_operator::$value_form_type	property		1
views_handler_filter_in_operator::$value_options	property	Stores all operations which are available on the form.
views_handler_filter_in_operator::accept_exposed_input	function	Check to see if input from the exposed filters should change the behavior of this filter. Overrides views_handler_filter::accept_exposed_input	2
views_handler_filter_in_operator::admin_summary	function	Display the filter on the administrative summary Overrides views_handler_filter::admin_summary	2
views_handler_filter_in_operator::construct	function	Views handlers use a special construct function so that we can more easily construct them with variable arguments. Overrides views_object::construct
views_handler_filter_in_operator::expose_form_right	function	Handle the 'right' side fo the exposed options form. Overrides views_handler_filter::expose_form_right	1
views_handler_filter_in_operator::expose_options	function	Provide default options for exposed filters. Overrides views_handler_filter::expose_options
views_handler_filter_in_operator::get_value_options	function	Child classes should be used to override this function and set the 'value options', unless 'options callback' is defined as a valid function or static public method to generate these values.	14
views_handler_filter_in_operator::operators	function	This kind of construct makes it relatively easy for a child class to add or remove functionality by overriding this function and adding/removing items from this array.	1
views_handler_filter_in_operator::operator_options	function	Build strings from the operators() for 'select' options Overrides views_handler_filter::operator_options	1
views_handler_filter_in_operator::operator_values	function
views_handler_filter_in_operator::option_definition	function	Information about options for all kinds of purposes will be held here. Overrides views_handler_filter::option_definition	1
views_handler_filter_in_operator::op_empty	function
views_handler_filter_in_operator::op_simple	function
views_handler_filter_in_operator::query	function	Add this filter to the query. Overrides views_handler_filter::query	3
views_handler_filter_in_operator::reduce_value_options	function	When using exposed filters, we may be required to reduce the set.
views_handler_filter_in_operator::validate	function	Validates the handler against the complete View. Overrides views_handler::validate
views_handler_filter_in_operator::value_form	function	Provide a form for setting options. Overrides views_handler_filter::value_form	2
views_handler_filter_in_operator::value_submit	function	Perform any necessary changes to the form values prior to storage. There is no need for this function to actually store the data. Overrides views_handler_filter::value_submit	2
views_object::$definition	property	Handler's definition
views_object::$options	property	Except for displays, options for the object will be held here.	1
views_object::destroy	function		2
views_object::export_option	function		1
views_object::export_options	function
views_object::options	function	Set default options on this object. Called by the constructor in a complex chain to deal with backward compatibility.	1
views_object::set_default_options	function	Set default options. For backward compatibility, it sends the options array; this is a feature that will likely disappear at some point.
views_object::set_definition	function	Let the handler know what its full definition is.
views_object::unpack_options	function	Unpack options over our existing defaults, drilling down into arrays so that defaults don't get totally blown away.
views_object::unpack_translatable	function	Unpack a single option definition.
views_object::unpack_translatables	function	Unpacks each handler to store translatable texts.
views_object::_set_option_defaults	function

You are here

class views_handler_filter_in_operator in Views (for Drupal 7) 6.3

Hierarchy

Related topics

File

Members

API Navigation