Club Drupal

 when clicking on the menu items. It produces nice breadcrumbs and page titles (remember to set 

 the titles for the arguments in views as described) - and it always displays descendants.

 The only module that supports the saving of a whole term lineage when selecting a deep level 

INTEGRATION WITH OTHER MODULES

==============================

It is a nice and very helpful module to link taxonomy terms to nodes. 

Taxonomy Menu does not interface with the content taxonomy tables, so be sure to enable the option 

"Save values additionally to the core taxonomy system (into the 'term_node' table)" 

(http://drupal.org/project/content_taxonomy)

HIERARCHICAL SELECT with submodule HS_TAXONOMY

================

 * Taxonomy Menu does not handle the menu call backs. It only creates the links to the menus.

   This means that everythign that is displayed on the page (including title, content, breadcrumbs, etc)

 * The router item must be created before Taxonomy Menu creates the links.  Failure to so so 

   will cause the menu items to not be created.

 * Router items can be created by either a view or another modules hook_menu.

 */

/**

 *

 */

function _taxonomy_menu_insert_link_items_batch($vid) {

  $menu_name = variable_get(_taxonomy_menu_build_variable('vocab_menu', $vid), FALSE);

  $batch = array(

    'operations' => array(

      array('_taxonomy_menu_insert_link_items_process', array($terms, $menu_name)),

    ),

    'finished' => '_taxonomy_menu_insert_link_items_success',

    'title' => t('Rebuilding Taxonomy Menu'),

    'init_message' => t('The menu items have been deleted, and are about to be regenerated.'),

    'progress_message' => t('Import progress: Completed @current of @total stages.'),

    'error_message' => t('The Taxonomy Menu rebuild process encountered an error.'),

  );

  batch_set($batch);

  batch_process();

}

 */

function _taxonomy_menu_insert_link_items_process($terms, $menu_name, &$context) {

  _taxonomy_menu_batch_init_context($context, $start, $end, 10);

 */

function _taxonomy_menu_insert_link_items_success() {

  // TODO state menu name here.

  drupal_set_message(t('The Taxonomy Menu has been updated.'));

}

 */

function _taxonomy_menu_batch_init_context(&$context, &$start, &$end, $items) {

  // Initialize sandbox the first time through.

  $end = $start + $items;

}

 * Update the batch context

 *

 */

function _taxonomy_menu_batch_update_context(&$context, $end, $total, $msg) {

  if ($end > $total) {

    $context['finished'] = 1;

    return;

 * Database functions

 */

 *

 */

function _taxonomy_menu_insert_menu_item($mlid, $tid, $vid) {

  $fields = array(

}

/**

 *

 */

function _taxonomy_menu_get_mlid($tid, $vid) {

  $where = array(

}

/**

 *

 * @param $vid

 */

function _taxonomy_menu_get_menu_items($vid) {

}

function _taxonomy_menu_delete_all($vid) {

  $menu_terms = _taxonomy_menu_get_menu_items($vid);

  if (!empty($menu_terms)) {

}

/**

 *

 */

function _taxonomy_menu_get_node_terms($node) {

  // Get the taxonomy fields.

    if (isset($node->$field_name)) {

      $tid_field = $node->$field_name;

      // Loop through all the languages.

      foreach ($tid_field as $tid_field_languages) {

        // Loop through all the tids

        foreach ($tid_field_languages as $tid) {

          $tids[] = $tid['tid'];

        }

}

/**

 *

 */

function _taxonomy_menu_get_parents($tid) {

  $output = array();

}

/**

function _taxonomy_menu_delete_item($vid, $tid) {

  $and = db_and()->condition('vid', $vid)->condition('tid', $tid);

  db_delete('taxonomy_menu')->condition($and)->execute();

}

/**

 *

 */

function _taxonomy_menu_get_terms($vid) {

  $result = db_select('taxonomy_term_data', 'td')

}

/**

 *

 *

 */

function _taxonomy_menu_term_count($tid) {

  $result = db_select('taxonomy_index', 'tn');

}

/**

 *

 */

function _taxonomy_menu_get_tid($mlid) {

}

/**

 *

 */

function _taxonomy_menu_get_item($mlid) {

  $result = db_select('taxonomy_menu', 'tm')

    ->condition('mlid', $mlid, '=')

    ->fields('tm', array('tid', 'vid'))

    ->execute();

  return $result->fetch();

}

/**

 * @return $vid

 */

function _taxonomy_menu_get_vid_by_tid($tids) {

  if ($tids) {

      ->fields('term_data', array('vid'))

      ->distinct()

      ->execute();

    return $result->fetchAllAssoc('vid');

  }

}

dependencies[] = taxonomy

dependencies[] = menu

files[] = taxonomy_menu.test

core = "7.x"

project = "taxonomy_menu"

 * Implements hook_uninstall().

 */

function taxonomy_menu_uninstall() {

  db_delete('menu_links')->condition('module', 'taxonomy_menu', '=')->execute();

  variable_set('menu_rebuild_needed', TRUE);

  $variables = $query->fetchAll();

  foreach ($variables as $variable) {

    }

  }

}

/**

 * Implements hook_schema().

 */

function taxonomy_menu_schema() {

  $schema['taxonomy_menu'] = array(

    'description' => 'Links a taxonomy term to a menu item.',

    'fields' => array(

/**

 * @file

 */

/**

 * Implements hook_form_alter().

 */

function taxonomy_menu_form_alter(&$form, &$form_state, $form_id) {

  if ($form_id == 'taxonomy_form_vocabulary') {

    if (isset($form_state['confirm_delete']) && isset($form_state['values']['vid'])) {

      return;

    }

      '#title' => t('Menu location'),

      '#default_value' => $default,

      '#options' => $menu_items,

      '#attributes' => array('class' => array('menu-title-select')),

    );

      '#description' => t('The path will be taxonomy/term/tid if <em>Default</em> has been selected.<br />The menu path will be passed through drupal_get_path_alias() function so all aliases will be applied.'),

    );

    if (isset($form['vid']) && $form['vid']['#value']) {

      $vid = $form['vid']['#value'];

    }

    }

    $form['taxonomy_menu']['options'] = _taxonomy_menu_create_options($vid);

    $form['taxonomy_menu']['options']['rebuild'] = array(

      '#type' => 'checkbox',

      '#default_value' => 0,

      '#weight' => 20,

    );

    $form['submit']['#weight'] = 49;

    $form['delete']['#weight'] = 50;

    $form['#submit'][] = 'taxonomy_menu_vocab_submit';

  }

  elseif ($form_id == "taxonomy_overview_terms") {

    // @ TODO: using hook_taxonomy_vocabulary_update is nicer then callback,

    $form['#submit'][] = 'taxonomy_menu_overview_submit';

  }

}

  $changed = FALSE;

  if (is_numeric($form_state['values']['taxonomy_menu']['vocab_parent'])) {

    $form_state['values']['taxonomy_menu']['vocab_parent'] = '0:0';

  }

  // Split the menu location into menu name and menu item id.

  list($vocab_parent['vocab_menu'], $vocab_parent['vocab_parent']) = explode(':', $form_state['values']['taxonomy_menu']['vocab_parent']);

  $changed_menu = FALSE;

  $change_vocab_item = FALSE;

  $changed_path = FALSE;

  $variable_name = _taxonomy_menu_build_variable('vocab_menu', $vid);

  if (_taxonomy_menu_check_variable($variable_name, $vocab_parent['vocab_menu'])) {

    $changed_menu = TRUE;

  }

  variable_set($variable_name, $vocab_parent['vocab_menu']);

  $variable_name = _taxonomy_menu_build_variable('vocab_parent', $vid);

  if (_taxonomy_menu_check_variable($variable_name, $vocab_parent['vocab_parent'])) {

    $changed_menu = TRUE;

  }

  variable_set($variable_name, $vocab_parent['vocab_parent']);

  $variable_name = _taxonomy_menu_build_variable('path', $vid);

  if (_taxonomy_menu_check_variable($variable_name, $form_state['values']['taxonomy_menu']['path'])) {

    $changed_path = TRUE;

    // Create the variable name

    $variable_name = _taxonomy_menu_build_variable($key, $vid);

    if ($key == 'voc_item') {

      if (_taxonomy_menu_check_variable($variable_name, $value)) {

        $change_vocab_item = TRUE;

      }

    }

    if (!$changed) {

      // Check to see if the variable has changed.

      if (_taxonomy_menu_check_variable($variable_name, $value)) {

    // Only send a message if one has been created.

    if (isset($message) && $message) {

      // $message is sanitized coming out of its source function,

      drupal_set_message($message, 'status');

    }

  }

}

/**

 */

function taxonomy_menu_overview_submit(&$form, &$form_state) {

  // Only sync if taxonomy_menu is enabled for this vocab and the 'sync'

    $vid = $form['#vocabulary']->vid;

  }

  elseif ($form_state['rebuild'] == TRUE && isset($form['#vocabulary']->vid) ) {

    $vid = NULL;

  }

  elseif ($form_state['rebuild'] == FALSE && isset($form['vid']['#value']) ) {

      // Report status.

      if (isset($message)) {

        drupal_set_message($message, 'status');

      }

}

/**

 *

 */

function _taxonomy_menu_rebuild($vid) {

  _taxonomy_menu_delete_all($vid);

  if (variable_get(_taxonomy_menu_build_variable('vocab_menu', $vid), FALSE)) {

    _taxonomy_menu_insert_link_items($vid);

    menu_rebuild();

/**

 * Checks to see if the variable has changed.

 *

 */

function _taxonomy_menu_check_variable($variable, $new_value) {

  if ($new_value != variable_get($variable, FALSE)) {

}

/**

 *

 * @param $vid

 */

function _taxonomy_menu_update_link_items($vid) {

  $menu_name = variable_get(_taxonomy_menu_build_variable('vocab_menu', $vid), FALSE);

  $menu_links = _taxonomy_menu_get_menu_items($vid);

  foreach ($menu_links as $tid => $mlid) {

    // $args must be reset each time through.

    $args = array(

      'menu_name' => $menu_name,

      $args['term'] = taxonomy_term_load($tid);

    }

    taxonomy_menu_handler('update', $args);

  }

}

/**

 *

 * @param $vid

 */

function _taxonomy_menu_insert_link_items($vid) {

  $menu_name = variable_get(_taxonomy_menu_build_variable('vocab_menu', $vid), FALSE);

  if (variable_get(_taxonomy_menu_build_variable('voc_item', $vid), FALSE)) {

      $args = array(

        'vid' => $vid,

      );

      taxonomy_menu_handler('insert', $args);

    }

  _taxonomy_menu_insert_link_items_batch($vid);

}

 * Implements hook_taxonomy_vocabulary_delete().

 */

function taxonomy_menu_taxonomy_vocabulary_delete($vocabulary) {

  _taxonomy_menu_delete_all($vocabulary->vid);

  $menu_name = variable_get(_taxonomy_menu_build_variable('vocab_menu', $vocabulary->vid), 0);

  menu_cache_clear($menu_name);

}

/**

 * Implements hook_taxonomy_term_insert($term).

 */

function taxonomy_menu_taxonomy_term_insert($term) {

  _taxonomy_menu_taxonomy_termapi_helper($term, 'insert');

}

/**

 * Implements hook_taxonomy_term_update().

 */

function taxonomy_menu_taxonomy_term_update($term) {

  _taxonomy_menu_taxonomy_termapi_helper($term, 'update');

}

/**

 * Implements hook_taxonomy_term_delete().

 */

function taxonomy_menu_taxonomy_term_delete($term) {

  _taxonomy_menu_taxonomy_termapi_helper($term, 'delete');

}

function taxonomy_menu_node_insert($node) {

  $terms_old = &drupal_static('taxonomy_menu_terms_old');

  // We use this direct table pull to avoid the cache and because

  // tid's is easy.

  $terms_new = _taxonomy_menu_get_node_terms($node);

 * Implements hook_node_update().

 */

function taxonomy_menu_node_update($node) {

}

/**

 */

function taxonomy_menu_node_presave($node) {

  $terms_old = &drupal_static('taxonomy_menu_terms_old');

  if (isset($node->nid)) {

    $node_old = node_load($node->nid);

    $terms_old = _taxonomy_menu_get_node_terms($node_old);

 * Implements hook_node_delete().

 */

function taxonomy_menu_node_delete($node) {

  $terms =  _taxonomy_menu_get_node_terms($node);

  _taxonomy_menu_nodeapi_helper('delete', $terms, $node);

}

  // option has been checked.

  $menu_name = variable_get(_taxonomy_menu_build_variable('vocab_menu', $term->vid), 0);

  $sync = variable_get(_taxonomy_menu_build_variable('sync', $term->vid), 0);

    $item = array(

      'tid' => $term->tid,

      'vid' => $term->vid,

    }

    $message = t($text, array('%term' => $term->name, '%menu_name' => $menu_name));

    taxonomy_menu_handler($operation, $item);

    drupal_set_message($message, 'status');

    menu_cache_clear($menu_name);

  }

}

/**

 * Builds argument arrays calls taxonomy_menu_handler.

 *

 * @param $node

 */

function _taxonomy_menu_nodeapi_helper($op, $terms = array(), $node) {

  foreach ($terms as $key => $tid) {

    if (!$term = taxonomy_term_load($tid)) {

      continue;

    }

    $menu_name = variable_get(_taxonomy_menu_build_variable('vocab_menu', $term->vid), FALSE);

    $vocb_sync = variable_get(_taxonomy_menu_build_variable('sync', $term->vid), TRUE);

    $menu_num = variable_get(_taxonomy_menu_build_variable('display_num', $term->vid), TRUE);

    $hide_empty = variable_get(_taxonomy_menu_build_variable('hide_empty_terms', $term->vid), FALSE);

    if ($menu_name && $vocb_sync && ($menu_num || $hide_empty)) {

      $args = array(

        'tid' => $term->tid,

        'vid' => $term->vid,

      }

      taxonomy_menu_handler($op, $args, $node);

        _taxonomy_menu_update_all_parents($term, $menu_name);

      }

    }

}

/**

 *

 * @param $node

 */

function _taxonomy_menu_update_all_parents($term, $menu_name) {

  $parents = taxonomy_get_parents($term->tid);

}

/**

 *

 * @param $op

 * @param $node

 *

 */

function taxonomy_menu_handler($op, $args = array(), $node = NULL, $item = array()) {

  if (empty($item)) {

    $item = _taxonomy_menu_create_item($args, $node);

  }

  $hook = 'taxonomy_menu_' . $op;

  foreach (module_implements($hook) as $module) {

    $function = $module . '_' . $hook;

    $function($item);

  }

  if ($op != 'delete') {

    return _taxonomy_menu_save($item);

  }

 *     'mlid' => if this is filled in then the mlid will be updated

 */

function _taxonomy_menu_save($item) {

  $insert = TRUE;

  // Child items should appear around the parent/root, so set their weight

  if ($flatten_menu) {

    $item['weight'] = $item['root_term_weight'];

  }

  // create the path.

  $path = taxonomy_menu_create_path($item['vid'], $item['tid']);

  // - the parent tid's mlid

  // - the vocab menu item's mlid

  // - the menu parent setting for this vocab

    $plid = variable_get(_taxonomy_menu_build_variable('vocab_parent', $item['vid']), NULL);

  }

  if (drupal_strlen($path) > 256) {

    preg_match('/(.{256}.*?)\b/', $path, $matches);

    $path = rtrim($matches[1]);

    'link_title' => $item['name'],

    'menu_name' => $item['menu_name'],

    'plid' => $plid,

    'weight' => $item['weight'],

    'module' => 'taxonomy_menu',

    'expanded' => variable_get(_taxonomy_menu_build_variable('expanded', $item['vid']), TRUE),

    'link_path' => $path,

  );

  if (strpos($path, '?') !== FALSE) {

    $split = explode('?', $path);

    if (strpos($split[1], '?') !== FALSE) {

    }

  }

  if (isset($item['mlid']) && $item['mlid']) {

    $link['mlid'] = $item['mlid'];

    $insert = FALSE;

  }

  if (module_exists('i18n_menu')) {

    $link['options']['alter'] = TRUE;

    $link['language'] = $item['language'];

    $link['customized'] = 1;

  }

  if ($item['tid'] == 0) {

    $link['has_children'] = 1;

  }

    }

  }

  if ($mlid = menu_link_save($link)) {

    if ($insert) {

      _taxonomy_menu_insert_menu_item($mlid, $item['tid'], $item['vid']);

    }

}

/**

 *

 * @return array

 */

function _taxonomy_menu_get_paths() {

  return module_invoke_all('taxonomy_menu_path');

 * Creates the path for the vid/tid combination.

 *

 * @param $vid

 * @param $tid

 * @return string

 */

function taxonomy_menu_create_path($vid, $tid) {

  $function = variable_get(_taxonomy_menu_build_variable('path', $vid), 'taxonomy_menu_path_default');

  return $function($vid, $tid);

}

/**

 * Implements hook_taxonomy_menu_path().

 *

 * @return array

 */

function taxonomy_menu_taxonomy_menu_path() {

  $output = array(

}

/**

 */

function taxonomy_menu_path_default($vid, $tid) {

  if ($tid == 0) {

    $vtids = _taxonomy_menu_get_terms($vid);

    $path = "taxonomy/term/$end";

  }

  else {

    $path = 'taxonomy/term/' . $tid;

    if (variable_get(_taxonomy_menu_build_variable('display_descendants', $vid), FALSE)) {

      if (variable_get(_taxonomy_menu_build_variable('end_all', $vid), FALSE)) {

        $path .= '/all';

      }

      else {

        $terms = taxonomy_get_tree($vid, $tid);

        foreach ($terms as $term) {

          $tids[] = $term->tid;

        }

        }

      }

    }

}

/**

 *

 */

function taxonomy_menu_taxonomy_menu_delete(&$item) {

  menu_link_delete($item['mlid']);

  _taxonomy_menu_delete_item($item['vid'], $item['tid']);

  unset($item['mlid']);

}

/**

 *

 * @param $args

 *

 * @param $node

 */

function _taxonomy_menu_create_item($args = array(), $node) {

  if (isset($args['tid']) && isset($args['vid']) && $args['tid'] == 0 && variable_get(_taxonomy_menu_build_variable('voc_item', $args['vid']), 0)) {

    $vocab = taxonomy_vocabulary_load($args['vid']);

    $item = array(

    if (empty($term->parents)) {

      $term->parents = _taxonomy_menu_get_parents($term->tid);

      if (empty($term->parents)) {

        $term->parents = array(0 => '0');

      }

    }

    // a flat taxonomy menu.

    if (is_object($term)) {

      $term_parents = taxonomy_get_parents_all($term->tid);

    }

    else {

      $root_term_weight = 0;

    foreach ($term->parents as $parent) {

      $ptid = $parent;

      $item = array(

        'tid' => $term->tid,

        'name' => $term->name,

        'description' => variable_get(_taxonomy_menu_build_variable('term_item_description', $term->vid), 0) ? $term->description : '',

        'vid' => $term->vid,

        'ptid' => $ptid,

        'root_term_weight' => $root_term_weight,

      if (isset($args['mlid'])) {

        $item['mlid'] = $args['mlid'];

      }

      break;

    }

  }

}

/**

 *

 * @param $tid

 * @param $vid

 * @return boolean

 */

function _taxonomy_menu_children_has_nodes($tid, $vid, $return = FALSE) {

}

/**

 *

 * @return array

 */

function _taxonomy_menu_item($item) {

  if ($item['tid'] > 0) {

    $num = _taxonomy_menu_term_count($item['tid']);

    if ($num == 0 &&

        $item['remove'] = TRUE;