modules/taxonomy_filter/taxonomy_filter.module

<?php
// $Id: taxonomy_filter.module,v 1.20 2009/07/25 23:39:02 solotandem Exp $

/**
 * @file
 * The core Taxonomy Filter module containing the API bits.
 */

/*
 TODO - Overall tasks before release:
 Refactor data structures etc - weed out redundancies
 Investigate block caching when n_a modules installed
 Depth handling - both on the outgoing links and on term selection
 Check for unused functions
 Add back some sql_rewrite wrappers on database queries for sites that use access control on terms
 Documentation and commenting
 Add explanation text to admin UI
 Add Drupal 5 upgrade code
 Implement tests (maybe later once I understand it)
 */


// Define constants for variable defaults
define('TAXONOMY_FILTER_INPUT', 'taxonomy/term/%tids/%depth!feed'); // 'taxonomy/term/%tids/%depth/!feed'
define('TAXONOMY_FILTER_OUTPUT', 'taxonomy/term/%tids/%depth');
define('TAXONOMY_FILTER_CURRENT_BLOCK_TITLE', 'Search results');
define('TAXONOMY_FILTER_REFINE_BLOCK_TITLE', 'Refine your search');

module_load_include('inc', 'taxonomy_filter', 'taxonomy_filter.base');

/**
 * Implementation of hook_menu().
 */
function taxonomy_filter_menu() {
  $items = array();
  $items['admin/settings/taxonomy_filter'] = array(
    'title' => 'Taxonomy filter',
    'description' => 'Configure the taxonomy filter module.',
    'page callback' => 'taxonomy_filter_admin_list',
    'access arguments' => array('administer site configuration'),
    'file' => 'taxonomy_filter.admin.inc',
  );
  $items['admin/settings/taxonomy_filter/menus'] = array(
    'title' => 'Menus',
    'weight' => -5,
    'type' => MENU_DEFAULT_LOCAL_TASK,
  );
  $items['admin/settings/taxonomy_filter/general'] = array(
    'title' => 'General',
    'weight' => 0,
    'description' => 'General settings.',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('taxonomy_filter_admin_general'),
    'access arguments' => array('administer site configuration'),
    'file' => 'taxonomy_filter.admin.inc',
    'type' => MENU_LOCAL_TASK,
  );
  $items['admin/settings/taxonomy_filter/mappings'] = array(
    'title' => 'Mappings',
    'weight' => 7,
    'description' => 'Map menus to vocabs.',
    'page callback' => 'taxonomy_filter_admin_mappings',
    'access arguments' => array('administer site configuration'),
    'parent' => 'admin/settings/taxonomy_filter/',
    'file' => 'taxonomy_filter.admin.inc',
    'type' => MENU_LOCAL_TASK,
  );
  $items['admin/settings/taxonomy_filter/advanced'] = array(
    'title' => 'Advanced',
    'weight' => 10,
    'description' => 'Advanced settings.',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('taxonomy_filter_admin_advanced'),
    'access arguments' => array('administer site configuration'),
    'file' => 'taxonomy_filter.admin.inc',
    'type' => MENU_LOCAL_TASK,
  );
  $items['admin/settings/taxonomy_filter/%/edit'] = array(
    // TODO - fix breadcrumb for this page
    'title' => 'Edit Taxonomy Filter menu',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('taxonomy_filter_admin_menu_edit_form', 3),
    'access arguments' => array('administer site configuration'),
    'file' => 'taxonomy_filter.admin.inc',
    'type' => MENU_CALLBACK,
  );
  $items['admin/settings/taxonomy_filter/%/delete'] = array(
    'title' => 'Delete Taxonomy Filter menu',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('taxonomy_filter_admin_menu_delete_confirm', 3),
    'access arguments' => array('administer site configuration'),
    'file' => 'taxonomy_filter.admin.inc',
    'type' => MENU_CALLBACK,
  );
  $items['admin/settings/taxonomy_filter/mappings/%/edit'] = array(
    'title' => 'Edit Taxonomy Filter mappings',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('taxonomy_filter_admin_mappings_edit_form', 4),
    'access arguments' => array('administer site configuration'),
    'parent' => 'admin/settings/taxonomy_filter/mappings',
    'file' => 'taxonomy_filter.admin.inc',
    'type' => MENU_CALLBACK,
  );
  return $items;
}

/**
 * Implementation of hook_taxonomy().
 */
function taxonomy_filter_taxonomy($op, $type, $object = NULL) {
  // TODO: when manual block caching is implemented, the cache will need to be flushed
  // after taxonomy changes.
  if ($type == 'vocabulary') {
    taxonomy_filter_update_mappings();
  }
}

/**
 * Implementation of hook_enable().
 */
function taxonomy_filter_enable() {
  $filters = variable_get('taxonomy_filter_input', TAXONOMY_FILTER_INPUT);
  taxonomy_filter_parse_input_filters($filters);
  taxonomy_filter_update_mappings();
}

/**
 * Implementation of hook_help().
 */
function taxonomy_filter_help() {
  // TODO?
}

/**
 * Implementation of hook_forms().
 */
function taxonomy_filter_forms() {
  // use this for building menu settings forms?
}

/**
 * Implementation of hook_theme().
 */
function taxonomy_filter_theme($existing, $type, $theme, $path) {
  return array(
    'taxonomy_filter_admin_list_form_templates' => array(
      'arguments' => array('form' => array()),
      'file' => 'taxonomy_filter.theme.inc',
    ),
    'taxonomy_filter_admin_list_form_menus' => array(
      'arguments' => array('form' => array()),
      'file' => 'taxonomy_filter.theme.inc',
    ),
    'taxonomy_filter_admin_mappings_table' => array(
      'arguments' => array('form' => array()),
      'file' => 'taxonomy_filter.theme.inc',
    ),
    // Current criteria
    'taxonomy_filter_block_current_content' => array(
      'arguments' => array('terms' => NULL, 'block_info' => NULL),
      'file' => 'taxonomy_filter.theme.inc',
    ),
    'taxonomy_filter_current_item' => array(
      'arguments' => array('item' => NULL, 'block_info' => NULL),
      'file' => 'taxonomy_filter.theme.inc',
      'template' => 'taxonomy-filter-item',
    ),
    // Refine criteria
    'taxonomy_filter_block_content' => array(
      'arguments' => array('sections' => NULL, 'block_info' => NULL),
      'file' => 'taxonomy_filter.theme.inc',
    ),
    'taxonomy_filter_section' => array(
      'arguments' => array('section' => NULL, 'block_info' => NULL),
      'file' => 'taxonomy_filter.theme.inc',
      'template' => 'taxonomy-filter-section',
    ),
    'taxonomy_filter_item' => array(
      'arguments' => array('item' => NULL, 'section_info' => NULL, 'block_info' => NULL),
      'file' => 'taxonomy_filter.theme.inc',
      'template' => 'taxonomy-filter-item',
    ),
    'taxonomy_filter_link' => array(
      'arguments' => array('name' => NULL, 'attributes' => NULL),
      'file' => 'taxonomy_filter.theme.inc',
    ),
  );
}

/**
 * Implementation of hook_block().
 */
function taxonomy_filter_block($op = 'list', $delta = 0, $edit = array()) {
  if ($op == 'list') {
    $blocks = array();
    $blocks[0] = array(
      'info' => t('Taxonomy filter - refine criteria'),
      // cache per page as menu is different for each url
      // no point also caching per user or role - it would only vary if a node
      // access module is installed and that bypasses block caching anyway.
      // See: http://drupal.org/node/80951 and http://drupal.org/node/186636
      // TODO: (later) implement manual per user or role caching
      'cache' => BLOCK_CACHE_PER_PAGE,
    );
    $blocks[1] = array(
      'info' => t('Taxonomy filter - current criteria'),
      'cache' => BLOCK_CACHE_PER_PAGE,
      'weight' => -20,
    );
    return $blocks;
  }
  elseif ($op == 'view') {
    $block = array();
    // Check url to see if we should display on this page.
    $url_tokens = taxonomy_filter_get_url_tokens();
    if ($url_tokens['tids'] && $url_tokens['op'] != 'feed') {
      // TODO Depth returns as '3!feed' - parsing is incorrect - what happened in 5.x??? Same thing!
      $depth = _taxonomy_filter_validate_depth($url_tokens['depth']);
      $tids = _taxonomy_filter_validate_tids($url_tokens['tids']);
      switch($delta) {
        case 0:
          // Refine search criteria block.
          if (count($tids) > 0) {
            $block_data = taxonomy_filter_block_refine($tids, $depth);
            $block = array(
              'subject' => filter_xss_admin($block_data['title']),
              'content' => theme('taxonomy_filter_block_content', $block_data['sections'], $block_data['info']),
            );
          }
          break;

        case 1:
          // Current search criteria block.
          $block_data = taxonomy_filter_block_current_NEW($tids, $depth);
          $block = array(
            'subject' => filter_xss_admin($block_data['title']),
            'content' => theme('taxonomy_filter_block_content', $block_data['sections'], $block_data['info']),
          );
          break;
      }
      return $block;
    }
  }
}

function taxonomy_filter_block_current($url_tids, $url_depth = NULL) {
//  drupal_set_title('Search results'); // User-setting or based on url alias or content?
  $terms = array();
  foreach ($url_tids as $tid) {
    $terms[] = taxonomy_get_term($tid);
  }
  foreach ($terms as $term) {
    $term->vocab_name = taxonomy_vocabulary_load($term->vid)->name;
  }
  $block['title'] = t('Search results'); // TODO Use caption in settings.
  $block['terms'] = $terms;
  $block['info'] = array(
    'url_tids' => $url_tids,
    'url_depth' => $url_depth,
  );
  return $block;
}

/**
 * Return array for current search results block.
 *
 * @param array $url_tids Term IDs.
 * @param integer $url_depth Depth of taxonomy terms to display (NA).
 * @return array Block content.
 */
function taxonomy_filter_block_current_NEW($url_tids, $url_depth = NULL) {
  $terms = array();
  foreach ($url_tids as $tid) {
    $terms[] = taxonomy_get_term($tid);
  }
  $block['sections'] = array();
  $block['info'] = array(
    'url_tids' => $url_tids,
    'url_depth' => $url_depth,
  );
  $sections_info = taxonomy_filter_sections_info_NEW($block['info']);
  if (!$sections_info) {
    return $block;
  }
  foreach ($sections_info as $section_info) {
    $module = $section_info['module']; // TODO Implement other menu templates?
     // TODO Context menu is not implemented for the current search block.
    $section_info['module'] = $module == 'tf_context' ? 'taxonomy_filter' : $module;
    $section_terms = array();
    foreach ($terms as $term) {
      if ($term->vid == $section_info['vid']) {
        $section_terms[] = $term;
      }
    }
    $items = array();
    if (count($section_terms) > 0) {
      $items = taxonomy_filter_section_items($section_terms, $section_info, $block['info']);
    }

    if (!count($items)) {
      continue;
    }
    $section = array(
      'title' => $section_info['section_title'],
      'items' => $items,
      'info' => $section_info,
    );
    drupal_alter('tf_section', $section, $block['info']);
    $block['sections'][] = $section;
  }
  drupal_alter('tf_block', $block);
  $settings = variable_get('taxonomy_filter_general', array());
  $block['title'] = isset($settings['current_block_title']) ? t($settings['current_block_title']) : t(TAXONOMY_FILTER_CURRENT_BLOCK_TITLE); // JB NEW Override tf_multi
  return $block;
}

function taxonomy_filter_sections_info_NEW($block_info) {
  $all_mappings = variable_get('taxonomy_filter_mappings', array());
  $menus = variable_get('taxonomy_filter_menus', array());

  $sections = array();
  $url_tids = $block_info['url_tids'];
  $sql = "SELECT DISTINCT(vid) FROM {term_data} WHERE tid IN (". db_placeholders($url_tids) .")";
  $result = db_query($sql, $url_tids);
  while ($row = db_fetch_object($result)) {
    $vid = $row->vid;

    $menu_id = $all_mappings[$vid]['current_menu'] ? $all_mappings[$vid]['current_menu'] : $all_mappings[$vid]['refine_menu'];
    $menu = $menus[$menu_id];
    $section = array(
      // TODO - this needs some refactoring / clean up
      'section_title' => check_plain($all_mappings[$vid]['vocab']),
      'vid' => $vid,
      'menu_id' => $menu_id,
      'module' => $menu['module'], // use $module_tf_section to get data
      'section_settings' => $menu,
      'class' => array('section', $menu['module']), // TODO - should we use template name instead of module name?
    );
    $sections[] = $section;
  }
  return $sections;
}

// Rename from taxonomy_filter_block_data

/**
 * Block builder.
 *
 * @param array $url_tids Term ids in page URL.
 * @param integer $url_depth Depth of terms to display.
 * @return array Block content.
 */
function taxonomy_filter_block_refine($url_tids, $url_depth = NULL) {
//  drupal_set_title('Search results');

  $first_term = taxonomy_get_term($url_tids[0]);
  // TODO Do we want to offer this option???
  $block['title'] = t('Select topics tagged with \'@term\' and:', array('@term' => $first_term->name));

  $settings = variable_get('taxonomy_filter_general', array());
  $block['title'] = isset($settings['refine_block_title']) ? t($settings['refine_block_title']) : t(TAXONOMY_FILTER_REFINE_BLOCK_TITLE); // JB NEW Override tf_multi

  $block['sections'] = array();
  $block['info'] = array(
    'url_tids' => $url_tids,
    'url_depth' => $url_depth,
  );
  $sections_info = taxonomy_filter_sections_info($block['info']);
  if (!$sections_info) {
    return $block;
  }
  foreach ($sections_info as $section_info) {
    $module = $section_info['module'];
    $items = taxonomy_filter_invoke($module, 'tf_section', $section_info, $block['info']);
    if (!count($items)) {
      continue;
    }
    $section = array(
      'title' => $section_info['section_title'],
      'items' => $items,
      'info' => $section_info,
    );
    drupal_alter('tf_section', $section, $block['info']);
    $block['sections'][] = $section;
  }
  drupal_alter('tf_block', $block);
  return $block;
}

/**
 * Section builder (where section is a vocabulary).
 *
 * @param array $block_info Block information.
 * @return array $sections
 *   Section information - title, menu id, module that renders this menu template, etc.
 */
function taxonomy_filter_sections_info($block_info) {
  $sections = array();
  $url_tids = $block_info['url_tids'];
  $sql = "SELECT DISTINCT(vid) FROM {term_data} WHERE tid IN (". db_placeholders($url_tids) .")";
  $result = db_query($sql, $url_tids);
  while ($row = db_fetch_object($result)) {
    $term_vids[] = $row->vid;
  }
  $all_mappings = variable_get('taxonomy_filter_mappings', array());
  $menus = variable_get('taxonomy_filter_menus', array());
  foreach ($all_mappings as $vid => $vid_mapping) {
    $menu_id = $vid_mapping['refine_menu'];
    // array_intersect is not strict enough; we need a subset relationship
    if (!array_diff($term_vids, $vid_mapping['mappings']) && $menu_id != 0) {
      $menu = $menus[$menu_id];
      $section = array(
        // TODO - this needs some refactoring / clean up
        'section_title' => $vid_mapping['vocab'],
        'vid' => $vid,
        'menu_id' => $menu_id,
        'module' => $menu['module'], // use $module_tf_section to get data
        'section_settings' => $menu,
        'class' => array('section', $menu['module']), // TODO - should we use template name instead of module name?
      );
      $sections[] = $section;
    }
  }
  return $sections;
}

/**
 * Return list of terms to display in this section.
 *
 * @param array $section_info Section information.
 * @param array $block_info Block information.
 * @return array Section items.
 */
function taxonomy_filter_tf_section($section_info, $block_info) {
  // Should we use taxonomy_get_tree for these functions?
  $context = NULL;
  $terms = array();
  $vid = $section_info['vid'];
  $tids = $block_info['url_tids'];
//  $menu_id = $section_info['menu_id']; // Not used

  $select = "SELECT td.vid, td.tid, td.name, COUNT(DISTINCT(n.nid)) AS count" .
         " FROM {term_data} td" .
         " INNER JOIN {term_node} tn ON tn.tid = td.tid";

  $joins = '';
  // By replacing %d with multiple %d's we could run this query at one time (from another function above)
  $wheres = ' WHERE td.vid IN (%d)';
  foreach ($tids as $index => $tid) {
    $joins .= ' INNER JOIN {term_node} tn' . $index . ' ON tn.nid = tn' . $index . '.nid';
    $wheres .= ' AND tn' . $index . '.tid IN ('. $tid .')';
  }
  $joins .= " INNER JOIN {node} n ON tn.nid = n.nid";
  $wheres .= ' AND n.status = 1 AND n.moderate = 0';
  $group = ' GROUP BY td.vid, td.tid, td.name, td.weight';
  $order = ' ORDER BY vid, weight, name';

  $sql = $select . $joins . $wheres . $group . $order;
  $sql = db_rewrite_sql($sql);

  $result = db_query($sql, $vid);
  while ($term = db_fetch_object($result)) {
    $terms[] = $term;
  }
  // If only one term, then the section is not needed as all existing nodes have this one term value.
  // Unset the section in the calling routine.
  $items = array();
  if (count($terms) > 0) {
    $items = taxonomy_filter_section_items($terms, $section_info, $block_info, $context);
  }
  return $items;
}

/**
 * Item builder.
 *
 * @param array $terms Term objects to produce items for.
 * @param array $section_info Section information.
 * @param array $block_info Block information.
 * @param unknown_type $context
 * @return array $items Item information.
 */
function taxonomy_filter_section_items($terms, $section_info, $block_info, $context = NULL) {
  $items = array();
  $module = $section_info['module'];
  foreach ($terms as $term) {
    $item_tid = $term->tid;
    $link_tids = taxonomy_filter_get_link_tids($block_info['url_tids'], $item_tid, $context);
    $item = array(
      'title' => check_plain($term->name),
      'item_attributes' => array(),
      'link_attributes' => array(),
      'info' => array(
        'item_tid' => $item_tid,
        'link_tids' => $link_tids,
      ),
    );
    if (isset($term->count)) {
      $item['info']['tf_count'] = $term->count;
    }
//    if ($term->template_settings) {
      // TODO - should this be template name not module name?
      $item['info'][$module] = ''; // $term->template_settings;
//    }
    drupal_alter('tf_item', $item, $section_info, $block_info, $context);
    // TODO Combine this with above alter after stabilizing module with tests.
    drupal_alter('tf_item_2', $item, $section_info, $block_info, $term, $context);
    $items[] = $item;
  }
  return $items;
}

function taxonomy_filter_get_link_tids($url_tids, $item_tid, $context = NULL) {
  $link_tids = array();
  if (!in_array($item_tid, $url_tids)) {
    // only return link tids for unselected items
//    $link_tids = array_merge($url_tids, array($item_tid)); // TEMP Code change made on 2009-04-28.
    $link_tids = array($url_tids[0], $item_tid); // TEMP Revert to code prior to 2009-04-28.
  }
  drupal_alter('tf_link_tids', $link_tids, $item_tid, $context);
  return $link_tids;
}

/**
 * generates paths for items.
 */
function _taxonomy_filter_format_path($tids, $depth, $op = NULL) {
  // if no tids return empty path (TODO do we need this check?)
  if (!$tids) return '';
  $template = variable_get('taxonomy_filter_output', TAXONOMY_FILTER_OUTPUT);
  $tid_str = implode(',', $tids);
  $depth_str = ($depth) ? $depth : '';
  $op_str = ($op) ? $op : '';

  $raw_url = str_replace('%tids', $tid_str, $template);
  $raw_url = str_replace('%depth', $depth_str, $raw_url);
  $raw_url = str_replace('%op', $op_str, $raw_url);
  $raw_url = str_replace('//', '/', $raw_url);
  $raw_url = trim($raw_url, '/');

  $url = drupal_get_path_alias(str_replace('%2C', ',', url($raw_url)));
  return $url;
}

/**
 * Check the current url against the list of urls to listen on.
 *
 * @return array Matched or unmatched tokens.
 */
function taxonomy_filter_get_url_tokens() {
  static $tokens;

  if (!is_null($tokens)) {
    return $tokens;
  }

  // TODO: make this extensible by other modules?
  $filter_array = variable_get('taxonomy_filter_input_parsed', array());
  $args = array();
  $argnum = 0;
  // create an array from arg(0), arg(1) etc
  while ($arg = arg($argnum)) {
    $args[] = $arg;
    $argnum++;
  }
  foreach ($filter_array as $filter_line) {
    $tids = NULL; // reset url variables
    $depth = NULL;
    $op = NULL;
    $min = min(count($args), count($filter_line)); // TODO - this needs rethinking for checking against extra params
    for ($i = 0; $i < $min; $i++) {
      $filter_bit = $filter_line[$i];
      $filter_bit_prefix = (strpos('/*%!', $filter_bit{0})) ? $filter_bit{0} : '' ; // uses a dummy '/' as pos 0
      if ($filter_bit_prefix == '') {
        if ($filter_bit != $args[$i]) {
          break;
        }
      }
      elseif ($filter_bit_prefix == '!') {
        if ($filter_bit == '!'. $args[$i]) {
          break;
        }
      }
      if ($filter_bit == '%tids') {
        $tids = $args[$i];
      }
      elseif ($filter_bit == '%depth') {
        $depth = $args[$i];
      }
      elseif ($filter_bit == '%op') {
        $op = $args[$i];
      }
    }
    if ($tids) {
      $tokens = array('tids' => $tids, 'depth' => $depth, 'op' => $op);
      return $tokens;
    }
  }
  $tokens = array('tids' => NULL, 'depth' => NULL, 'op' => NULL);
  return $tokens;
}

/**
 * Validate and convert the term ids in the url to an array.
 */
function _taxonomy_filter_validate_tids($raw_tids) {
  $tids = array();
  foreach (preg_split('/[+ ,]/', $raw_tids) as $tid) {
    if (is_numeric($tid) && (int) $tid > 0) {
      $tids[] = (int) $tid;
    }
  }
  return $tids;
}

/**
 * Validate the depth parameter in the current path.
 */
function _taxonomy_filter_validate_depth($raw_depth) {
  if (is_numeric($raw_depth)) {
    $depth = ($raw_depth > 0) ? min(9, (int) $raw_depth): 0;
  }
  else {
    $depth = ($raw_depth == 'all') ? 'all' : NULL;
  }
  return $depth;
}

function _taxonomy_filter_get_vocabs() {
  // TODO: use static array for performance?
  // TODO: supply vocab weight for further calcs?
  // TODO: use taxonomy_get_vocabularies?
  $vocabs = array();
  $result = db_query('SELECT v.vid, v.name FROM {vocabulary} v ORDER BY v.weight, v.name');
  while ($voc = db_fetch_object($result)) {
    $vocabs[$voc->vid] = $voc->name;
  }
  return $vocabs;
}

/**
 * Update mappings variable for vocabulary changes.
 */
function taxonomy_filter_update_mappings() {
  $vocabs = _taxonomy_filter_get_vocabs();
  $old_mappings = variable_get('taxonomy_filter_mappings', array());

  // Check for any deleted vocabularies.
  $vids = array_keys($vocabs);
  foreach ($old_mappings as $vid => &$old_mapping) {
    if (!array_key_exists($vid, $vocabs)) {
      // Delete the mapping variable entry for the deleted vocabulary.
      unset($old_mappings[$vid]);
    }
    elseif ($deleted_vids = array_diff($old_mapping['mappings'], $vids)) {
      // Delete any mappings pointing to the deleted vocabulary.
      foreach ($deleted_vids as $index => $deleted_vid) {
        $key = array_search($deleted_vid, $old_mapping['mappings']);
        unset($old_mapping['mappings'][$key]);
      }
    }
  }

  // Recreate the entire variable to synchronize the filter menu "display"
  // order to a vocabulary weight change.
  $new_mappings = array();
  foreach ($vocabs as $vid => $name) {
    if (array_key_exists($vid, $old_mappings)) {
      // For existing mappings:
      // - store the current vocabulary name (it may have changed).
      // - create a mappings item if not present.
      $new_mappings[$vid] = array(
        'vocab' => $name,
        'refine_menu' => $old_mappings[$vid]['refine_menu'],
        'current_menu' => $old_mappings[$vid]['current_menu'],
        'mappings' => isset($old_mappings[$vid]['mappings']) ? $old_mappings[$vid]['mappings'] : array(),
      );
    }
    else {
      // For missing mappings, add default values.
      $new_mappings[$vid] = array(
        'vocab' => $name,
        'refine_menu' => 0,
        'current_menu' => 0,
        'mappings' => array(),
      );
    }
  }

  // Save the mappings.
  variable_set('taxonomy_filter_mappings', $new_mappings);
}

/**
 * Breaks the input filter patterns into component pieces.
 */
function taxonomy_filter_parse_input_filters($filters) {
  $input_bits = array();
  $lines = preg_split('/[\n\r]+/', trim($filters));
  foreach ($lines as $line) {
    $temp = array();
    $bits = explode('/', trim($line, '/'));
    foreach ($bits as $bit) {
      $temp[] = $bit;
    }
    $input_bits[] = $temp;
  }
  variable_set('taxonomy_filter_input_parsed', $input_bits);
}

function taxonomy_filter_invoke() {
  // Just like module_invoke() but falls back on base menu template implementation.
  $args = func_get_args();
  $module = $args[0];
  $hook = $args[1];
  unset($args[0], $args[1]);
  $function = $module .'_'. $hook;
  if (module_hook($module, $hook)) {
    return call_user_func_array($function, $args);
  }
  elseif (module_hook('taxonomy_filter', $hook)) {
    return call_user_func_array('taxonomy_filter_'. $hook, $args);
  }
}

/**
 * Get all tids in the url up to and including the current tid based on the
 * order selected by the user.
 *
 * @param array $tids
 * @param integer $this_tid
 * @return array
 */
function _taxonomy_filter_tids_upto($tids, $this_tid) {
  $length = 1;
  foreach ($tids as $tid) {
    if ($tid == $this_tid) {
      break;
    }
    $length++;
  }
  /*
   * On the last url tid omit a link to select all tids up to this tid as this
   * content is already being displayed.
   */
  if ($length == count($tids)) {
    return null;
  }
  return array_slice($tids, 0, $length);
}

/**
 * Return variables table entries for the 'taxonomy_filter_menus' key.
 *
 * TODO Is this useful?
 *
 * @param integer $menu_id First level index.
 * @param string $key Second level index.
 * @return array Values.
 */
function taxonomy_filter_menu_settings($menu_id, $key) {
  $menus = variable_get('taxonomy_filter_menus', array());
  $settings = array();
  if (isset($menus[$menu_id]) && isset($menus[$menu_id][$key])) {
    $settings = $menus[$menu_id][$key];
  }
  return $settings;
}

/**
 * Process variables for page.tpl.php.
 *
 * This preprocess function works because the page hook is in a template.
 * If the page hook was in a theme function then this would not be possible.
 */
function taxonomy_filter_preprocess_page(&$variables) {
  // Check url to see if we should display on this page.
  $url_tokens = taxonomy_filter_get_url_tokens();
  if ($url_tokens['tids'] && $url_tokens['op'] != 'feed') {
    $settings = variable_get('taxonomy_filter_general', array());
    if (isset($settings['display_current_atop_content']) && $settings['display_current_atop_content']) {
      $variables['title'] = isset($settings['current_block_title']) ? t($settings['current_block_title']) : t(TAXONOMY_FILTER_CURRENT_BLOCK_TITLE);
      $depth = _taxonomy_filter_validate_depth($url_tokens['depth']);
      $tids = _taxonomy_filter_validate_tids($url_tokens['tids']);
      $block_data = taxonomy_filter_block_current($tids, $depth);

      $new = '';
      $new .= '<div class="clear-block block block-taxonomy_filter" id="block-taxonomy_filter-2">';
      $new .= '<div class="content">';
      $new .= '<ul>';
      $new .= theme('taxonomy_filter_block_current_content', $block_data['terms'], $block_data['info']);
      $new .= '</ul>';
      $new .= '</div>';
      $new .= '</div>';
      $variables['content'] = $new . $variables['content'];
    }
  }
}