autocomplete_deluxe.module in Autocomplete Deluxe 7

Define enhanced autocomplete wdiget.

File

autocomplete_deluxe.module

<?php

/**
 * @file
 * Define enhanced autocomplete wdiget.
 */

/**
 * Implements hook_field_info().
 */
function autocomplete_deluxe_field_widget_info() {
  return array(
    'autocomplete_deluxe_taxonomy' => array(
      'label' => t('Autocomplete Deluxe'),
      'field types' => array(
        'taxonomy_term_reference',
      ),
      'settings' => array(
        'size' => 60,
        'autocomplete_deluxe_path' => 'autocomplete_deluxe/taxonomy',
      ),
      'behaviors' => array(
        'multiple values' => FIELD_BEHAVIOR_CUSTOM,
      ),
    ),
    'autocomplete_deluxe_list' => array(
      'label' => t('Autocomplete Deluxe'),
      'field types' => array(
        'list',
        'list_text',
        'list_text',
        'list_integer',
        'list_float',
      ),
      'settings' => array(
        'size' => 60,
      ),
      'behaviors' => array(
        'multiple values' => FIELD_BEHAVIOR_CUSTOM,
      ),
    ),
  );
}

/**
 * Custom taxonomy callback, which also accepts an empty string search.
 */
function taxonomy_autocomplete_deluxe($field_name, $tags_typed = '') {
  $field = field_info_field($field_name);

  // The user enters a comma-separated list of tags. We only autocomplete the last tag.
  $tags_typed = drupal_explode_tags($tags_typed);
  $tag_last = drupal_strtolower(array_pop($tags_typed));
  $matches = array();

  // Part of the criteria for the query come from the field's own settings.
  $vids = array();
  $vocabularies = taxonomy_vocabulary_get_names();
  foreach ($field['settings']['allowed_values'] as $tree) {
    $vids[] = $vocabularies[$tree['vocabulary']]->vid;
  }
  $query = db_select('taxonomy_term_data', 't');
  $query
    ->addTag('translatable');
  $query
    ->addTag('term_access');
  $query
    ->addTag('autocomplete_deluxe_taxonomy_autocomplete');
  $query
    ->addMetadata('field_name', $field_name);
  if ($tag_last != '') {

    // Do not select already entered terms.
    if (!empty($tags_typed)) {
      $query
        ->condition('t.name', $tags_typed, 'NOT IN');
    }

    // Select rows that match by term name.
    $tags_return = $query
      ->fields('t', array(
      'tid',
      'name',
    ))
      ->condition('t.vid', $vids)
      ->condition('t.name', '%' . db_like($tag_last) . '%', 'LIKE')
      ->execute()
      ->fetchAllKeyed();
  }
  else {
    $tags_return = $query
      ->fields('t', array(
      'tid',
      'name',
    ))
      ->condition('t.vid', $vids)
      ->execute()
      ->fetchAllKeyed();
  }
  $prefix = count($tags_typed) ? implode(', ', $tags_typed) . ', ' : '';
  $term_matches = array();
  foreach ($tags_return as $tid => $name) {
    $n = $name;

    // Term names containing commas or quotes must be wrapped in quotes.
    if (strpos($name, ',') !== FALSE || strpos($name, '"') !== FALSE) {
      $n = '"' . str_replace('"', '""', $name) . '"';
    }
    else {
      $term_matches[$prefix . $n] = check_plain($name);
    }
  }
  drupal_json_output($term_matches);
}

/**
 * Returns all allowed terms for a field without any prefix.
 */
function autocomplete_deluxe_allowed_terms($field) {
  $options = array();
  foreach ($field['settings']['allowed_values'] as $tree) {
    if ($vocabulary = taxonomy_vocabulary_machine_name_load($tree['vocabulary'])) {
      if ($terms = taxonomy_get_tree($vocabulary->vid, $tree['parent'])) {
        foreach ($terms as $term) {
          $options[$term->name] = $term->name;
        }
      }
    }
  }
  return $options;
}

/**
 * Implements hook_field_widget_settings_form().
 */
function autocomplete_deluxe_field_widget_settings_form($field, $instance) {
  $widget = $instance['widget'];
  $settings = $widget['settings'];
  $type = str_replace('autocomplete_deluxe_', '', $widget['type']);
  $form['size'] = array(
    '#type' => 'textfield',
    '#title' => t('Size of textfield'),
    '#default_value' => isset($settings['size']) ? $settings['size'] : 6,
    '#element_validate' => array(
      '_element_validate_integer_positive',
    ),
    '#required' => TRUE,
  );
  return $form;
}

/**
 * Implodes the tags from the taxonomy module.
 *
 * This function is essentially the same as axonomy_implode_tags, with the
 * difference, that it uses only a comma instead of a comma and a space to
 * implode the tags. It will help keep problems with delimiters to a minimum.
 */
function autocomplete_deluxe_taxonomy_implode_tags($tags, $vid = NULL) {
  $typed_tags = array();
  foreach ($tags as $tag) {

    // Extract terms belonging to the vocabulary in question.
    if (!isset($vid) || $tag->vid == $vid) {

      // Make sure we have a completed loaded taxonomy term.
      if (isset($tag->name)) {

        // Commas and quotes in tag names are special cases, so encode 'em.
        if (strpos($tag->name, ',') !== FALSE || strpos($tag->name, '"') !== FALSE) {
          $tag->name = '"' . str_replace('"', '""', $tag->name) . '"';
        }
        $typed_tags[] = $tag->name;
      }
    }
  }
  return implode(',', $typed_tags);
}

/**
 * Implements hook_field_widget_error().
 */
function autocomplete_deluxe_field_widget_error($element, $error, $form, &$form_state) {
  form_error($element, $error['message']);
}

/**
 * Implements hook_field_widget_form().
 */
function autocomplete_deluxe_field_widget_form(&$form, &$form_state, $field, $instance, $langcode, $items, $delta, $element) {
  $type = str_replace('autocomplete_deluxe_', '', $instance['widget']['type']);
  $element += array(
    '#type' => 'autocomplete_deluxe',
    '#size' => $instance['widget']['settings']['size'],
  );
  $multiple = $field['cardinality'] > 1 || $field['cardinality'] == FIELD_CARDINALITY_UNLIMITED ? TRUE : FALSE;
  switch ($type) {
    case 'taxonomy':
      $tags = array();
      foreach ($items as $item) {
        $tags[$item['tid']] = isset($item['taxonomy_term']) ? $item['taxonomy_term'] : taxonomy_term_load($item['tid']);
      }
      $element['#element_validate'] = array(
        'taxonomy_autocomplete_validate',
      );
      if (isset($instance['widget']['settings']['content_taxonomy_autocomplete_new_terms']) && $instance['widget']['settings']['content_taxonomy_autocomplete_new_terms'] == 'deny') {
        $options = autocomplete_deluxe_allowed_terms($field);
        $default_values = array();
        foreach ($tags as $tag) {
          $default_values[$tag->name] = $tag->name;
        }
        $element += array(
          '#autocomplete_options' => $options,
          '#multiple' => $multiple && count($options) > 1,
          '#default_value' => $default_values,
        );
      }
      else {
        $element += array(
          '#multiple' => $multiple,
          '#autocomplete_deluxe_path' => url($instance['widget']['settings']['autocomplete_deluxe_path'] . '/' . $field['field_name'], array(
            'absolute' => TRUE,
          )),
          '#default_value' => autocomplete_deluxe_taxonomy_implode_tags($tags),
        );
      }
      $form_state['autocomplete_deluxe']['terms'] = TRUE;
      break;
    case 'list':
      $value_key = key($field['columns']);
      $type = str_replace('options_', '', $instance['widget']['type']);
      $required = $element['#required'];
      $has_value = isset($items[0][$value_key]);
      $properties = _options_properties($type, $multiple, $required, $has_value);

      // Prepare the list of options.
      $options = _options_get_options($field, $instance, $properties);
      $default_value = _options_storage_to_form($items, $options, $value_key, $properties);
      $element += array(
        '#autocomplete_options' => $options,
        '#autocomplete_min_length' => 0,
        '#multiple' => $multiple && count($options) > 1,
        '#value_key' => $value_key,
        '#element_validate' => array(
          'options_field_widget_validate',
        ),
        '#properties' => $properties,
        '#default_value' => $default_value,
      );
      break;
  }
  return $element;
}

/**
 * Generates the basic form elements and javascript settings.
 */
function autocomplete_deluxe_element_process($element) {
  $element['#attached'] = array(
    'library' => array(
      array(
        'system',
        'ui.autocomplete',
      ),
      array(
        'system',
        'ui.button',
      ),
    ),
    'js' => array(
      drupal_get_path('module', 'autocomplete_deluxe') . '/autocomplete_deluxe.js',
    ),
    'css' => array(
      drupal_get_path('module', 'autocomplete_deluxe') . '/autocomplete_deluxe.css',
    ),
  );

  // Workaround for problems with jquery css in seven theme.
  if ($GLOBALS['theme'] == 'seven') {
    $element['#attached']['css'][] = drupal_get_path('module', 'autocomplete_deluxe') . '/autocomplete_deluxe.seven.css';
  }
  $html_id = drupal_html_id('autocomplete-deluxe-input');
  $element['#after_build'][] = 'autocomplete_deluxe_after_build';

  // Set default options for multiple values.
  $element['#multiple'] = isset($element['#multiple']) ? $element['#multiple'] : FALSE;
  $element['#prefix'] = '<div class="clearfix autocomplete-container">';
  $element['#suffix'] = '</div>';
  $element['values'] = array(
    '#type' => 'container',
    '#attributes' => array(
      'class' => array(
        'autocomplete-deluxe-values',
      ),
    ),
  );
  $element['textfield'] = array(
    '#type' => 'textfield',
    '#size' => isset($element['#size']) ? $element['#size'] : '',
    '#attributes' => array(
      'class' => array(
        'autocomplete-deluxe-form',
        'form-autocomplete',
      ),
      'id' => array(
        $html_id,
      ),
    ),
    '#default_value' => '',
  );
  $js_settings['autocomplete_deluxe'][$html_id] = array(
    'input_id' => $html_id,
    'min_length' => isset($element['#autocomplete_min_length']) ? $element['#autocomplete_min_length'] : 0,
    'multiple' => $element['#multiple'],
  );
  if (isset($element['#autocomplete_deluxe_path'])) {
    if ($element['#multiple']) {
      $element['value_field'] = array(
        '#type' => 'textfield',
        '#attributes' => array(
          'class' => array(
            'autocomplete-deluxe-value-field',
          ),
        ),
        '#default_value' => isset($element['#default_value']) ? $element['#default_value'] : '',
        '#prefix' => '<div class="autocomplete-deluxe-value-container">',
        '#suffix' => '</div>',
      );
      $element['textfield']['#attributes']['style'] = array(
        'display:none',
      );
    }
    else {
      $element['textfield']['#default_value'] = isset($element['#default_value']) ? $element['#default_value'] : '';
    }
    $js_settings['autocomplete_deluxe'][$html_id] += array(
      'type' => 'ajax',
      'uri' => $element['#autocomplete_deluxe_path'],
    );
  }
  elseif (isset($element['#autocomplete_options'])) {
    $js_settings['autocomplete_deluxe'][$html_id] += array(
      'type' => 'list',
      'data' => $element['#autocomplete_options'],
    );
    $html_id_select = drupal_html_id('autocomplete-deluxe-input-select');
    $element['list_value'] = array(
      '#type' => 'select',
      '#options' => $element['#autocomplete_options'],
      '#multiple' => $element['#multiple'],
      '#attributes' => array(
        'class' => array(
          'autocomplete-deluxe-form',
          'form-autocomplete',
        ),
        'id' => array(
          $html_id_select,
        ),
      ),
      '#default_value' => isset($element['#default_value']) ? $element['#default_value'] : '',
    );

    // Hide textfield so that, in case javascript is deactivated
    $element['textfield']['#attributes']['style'] = 'display: none;';
    $js_settings['autocomplete_deluxe'][$html_id]['select_input'] = $html_id_select;
  }
  else {

    // If there is no source (path or data), we don't want to add the js
    // settings and so the functions will be abborted.
    return $element;
  }
  $element['#attached']['js'][] = array(
    'data' => $js_settings,
    'type' => 'setting',
  );
  return $element;
}

/**
 * Helper function to determine the value for a autocomplete deluxe form
 * element.
 */
function autocomplete_deluxe_value(&$element, $input = FALSE, $form_state = NULL) {

  // This runs before child elements are processed, so we cannot calculate the
  // value here. But we have to make sure the value is an array, so the form
  // API is able to proccess the children to set their values in the array. Thus
  // once the form API has finished processing the element, the value is an
  // array containing the child element values. Then finally the after build
  // callback converts it back to the numeric value and sets that.
  return array();
}

/**
 * FAPI after build callback for the duration parameter type form.
 * Fixes up the form value by applying the multiplier.
 */
function autocomplete_deluxe_after_build($element, &$form_state) {

  // By default drupal sets the maxlength to 128 if the property isn't
  // specified, but since the limit isn't usefull in some cases,
  // we unset the property.
  unset($element['textfield']['#maxlength']);
  if (!isset($element['list_value'])) {
    $element['#value'] = isset($element['value_field']) ? $element['value_field']['#value'] : $element['textfield']['#value'];

    // Do the same for similar reasons as before.
    unset($element['value_field']['#maxlength']);
  }
  else {
    if (!empty($form_state['autocomplete_deluxe']['terms']) && !empty($element['#multiple'])) {
      $element['#value'] = !empty($element['list_value']['#value']) ? implode(',', $element['list_value']['#value']) : "";
    }
    else {
      $element['#value'] = $element['list_value']['#value'];
    }
  }
  form_set_value($element, $element['#value'], $form_state);
  return $element;
}

/**
 * Implements hook_element_info().
 */
function autocomplete_deluxe_element_info() {
  $types['autocomplete_deluxe'] = array(
    '#input' => TRUE,
    '#value_callback' => 'autocomplete_deluxe_value',
    '#pre_render' => array(
      'form_pre_render_conditional_form_element',
    ),
    '#process' => array(
      'autocomplete_deluxe_element_process',
    ),
  );
  return $types;
}

/**
 * Implements hook_menu().
 */
function autocomplete_deluxe_menu() {
  $items['autocomplete_deluxe/taxonomy'] = array(
    'title' => 'Autocomplete deluxe taxonomy',
    'page callback' => 'taxonomy_autocomplete_deluxe',
    'access arguments' => array(
      'access content',
    ),
    'type' => MENU_CALLBACK,
  );
  return $items;
}

Functions

Name	Description
autocomplete_deluxe_after_build	FAPI after build callback for the duration parameter type form. Fixes up the form value by applying the multiplier.
autocomplete_deluxe_allowed_terms	Returns all allowed terms for a field without any prefix.
autocomplete_deluxe_element_info	Implements hook_element_info().
autocomplete_deluxe_element_process	Generates the basic form elements and javascript settings.
autocomplete_deluxe_field_widget_error	Implements hook_field_widget_error().
autocomplete_deluxe_field_widget_form	Implements hook_field_widget_form().
autocomplete_deluxe_field_widget_info	Implements hook_field_info().
autocomplete_deluxe_field_widget_settings_form	Implements hook_field_widget_settings_form().
autocomplete_deluxe_menu	Implements hook_menu().
autocomplete_deluxe_taxonomy_implode_tags	Implodes the tags from the taxonomy module.
autocomplete_deluxe_value	Helper function to determine the value for a autocomplete deluxe form element.
taxonomy_autocomplete_deluxe	Custom taxonomy callback, which also accepts an empty string search.