modules/category/category.module

<?php
// $Id: category.module,v 1.161 2009/05/31 10:06:26 jaza Exp $

/**
 * @file
 * Allows users to structure their site and organize content with categories.
 */

/**
 * Implementation of hook_perm().
 */
function category_perm() {
  return array('administer categories');
}

/**
 * Implementation of hook_theme()
 */
function category_theme() {
  return array(
    'category_category_select' => array(
      'arguments' => array('element' => NULL),
    ),
    'category_page' => array(
      'arguments' => array('cids' => array(), 'result' => NULL),
    ),
    'category_overview_containers' => array(
      'arguments' => array('form' => array()),
    ),
    'category_overview_categories' => array(
      'arguments' => array('form' => array()),
    ),
    'category_wrapper_status' => array(
      'arguments' => array('type' => NULL, 'status' => NULL),
    ),
  );
}

/**
 * Implementation of hook_flush_caches()
 */
function category_flush_caches() {
  return array('cache_category');
}

/**
 * Implementation of hook_link().
 *
 * This hook is extended with $type = 'categories' to allow themes to
 * print lists of categories associated with a node. Themes can print category
 * links with:
 *
 * if (module_exists('category')) {
 *   $categories = category_link('categories', $node);
 *   print theme('links', $categories);
 * }
 */
function category_link($type, $node = NULL, $teaser = FALSE) {
  $links = array();

  // 'Add child' links, a la book.module.
  if ($type == 'node' && isset($node->category) && !$teaser) {
    if ($node->status == 1 && $node->category['depth'] < MENU_MAX_DEPTH) {
      foreach (node_get_types() as $node_type) {
        $behavior = variable_get('category_behavior_'. $node_type->type, 0);
        if (!empty($behavior) && node_access('create', $node_type->type)) {
          $allowed_containers = variable_get(
          'category_allowed_containers_'. $node_type->type, array());
          $print_link = FALSE;
          if ($node->category['behavior'] == 'container') {
            // If the current node is a container, and if the node type of the
            // link is a container, then always print a link.
            if ($behavior == 'container') {
              $print_link = TRUE;
            }
            else {
              // If the current node is a container, but the node type of the
              // link is a category, then print a link only if the current node
              // is an allowed container for the node type in question.
              if (empty($allowed_containers) || in_array($node->nid, $allowed_containers)) {
                $print_link = TRUE;
              }
            }
          }
          else {
            // If the current node is a category, and if the node type of the
            // link is a container, then always print a link.
            if ($behavior == 'container') {
              $print_link = TRUE;
            }
            else {
              $container = category_get_container($node->category['cnid']);
              if (!$container->tags) {
                // If the current node is a category, and the node type of the
                // link is also a category, then print a link only if the
                // container of the current node is an allowed container for
                // the node type in question.
                if ($container->hierarchy && (empty($allowed_containers) || in_array($node->category['cnid'], $allowed_containers))) {
                  $print_link = TRUE;
                }
                // If the current node and the node type of the link are both
                // categories, but the container of the current node is NOT an
                // allowed container for the node type, then print a link only
                // if one of the allowed containers for the node type in
                // question has the container of the current node as an allowed
                // parent.

                // Now say that backwards. ;-)
                else {
                  foreach ($allowed_containers as $allowed_cnid) {
                    $allowed_container = category_get_container($allowed_cnid);
                    if (!empty($allowed_container->allowed_parent) && $allowed_container->allowed_parent == $container->cid) {
                      $print_link = TRUE;
                      break;
                    }
                  }
                }
              }
            }
          }

          if ($print_link) {
            $links['category_add_'. $node_type->type] = array(
              'title' => t('Add child @type', array('@type' => drupal_strtolower($node_type->name))),
              'href' => 'node/add/'. str_replace('_', '-', check_plain($node_type->type)),
              'query' => 'parent='. $node->nid,
            );
          }
        }
      }
    }

    return $links;
  }

  // Assigned category links, a la taxonomy.module.
  if ($type == 'categories' && $node != NULL) {
    // If previewing, the categories must be converted to objects first.
    if ($node->build_mode == NODE_BUILD_PREVIEW) {
      $node->categories = category_preview_categories($node);
    }
    if (isset($node->categories) && is_array($node->categories)) {
      foreach ($node->categories as $category) {
        // During preview the free tagging categories are in an array unlike the
        // other categories which are objects. So we have to check if a $category
        // is an object or not.
        if (is_object($category)) {
          $category_display = NULL;
          if (module_exists('category_display')) {
            $category_display = category_display_get_container($category->cnid);
          }
          if (!isset($category_display) || !empty($category_display->nodelinks)) {
            $links['category_cat_'. $category->cid] = array(
              'title' => $category->title,
              'href' => category_category_path($category),
              'attributes' => array(
                'rel' => 'tag',
                'title' => check_plain(strip_tags($category->description)),
              ),
            );
          }
        }
        // Previewing free tagging categories; we don't link them because the
        // category-page might not exist yet.
        else {
          foreach ($category as $free_typed) {
            $typed_categories = drupal_explode_tags($free_typed);
            $types_categories_count = 0;
            foreach ($typed_categories as $typed_category) {
              $links['category_preview_cat_'. $types_categories_count] = array(
                'title' => $typed_category,
              );
              $types_categories_count++;
            }
          }
        }
      }
    }

    // We call this hook again because some modules and themes
    // call category_link('categories') directly.
    drupal_alter('link', $links, $node);

    return $links;
  }
}

/**
 * For containers not maintained by category.module, give the maintaining
 * module a chance to provide a path for categories in that container.
 *
 * @param $category
 *   A category object.
 * @return
 *   An internal Drupal path.
 */

function category_category_path($category) {
  if (function_exists('taxonomy_term_path')) {
    $node = $category;
    $node->category = (array) $category;
    return taxonomy_term_path((object) _taxonomy_category_into_term($node));
  }
  return 'node/'. $category->cid;
}

/**
 * Implementation of hook_menu().
 */
function category_menu() {
  $items = array();

  $items['admin/content/category'] = array(
    'title' => 'Categories',
    'description' => 'Manage category hierarchies and classification of your content.',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('category_overview_containers'),
    'access arguments' => array('administer categories'),
    'file' => 'category.admin.inc',
  );
  $items['admin/content/category/list'] = array(
    'title' => 'List',
    'type' => MENU_DEFAULT_LOCAL_TASK,
    'weight' => -10,
  );
  $items['admin/content/category/add'] = array(
    'title' => 'Add container',
    'page callback' => 'category_add_container_page',
    'access arguments' => array('administer categories'),
    'type' => MENU_LOCAL_TASK,
    'weight' => -9,
    'file' => 'category.admin.inc',
  );
  $items['admin/content/category/wrappers'] = array(
    'title' => 'Wrapper modules',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('category_wrapper_admin_page'),
    'access arguments' => array('administer categories'),
    'type' => MENU_LOCAL_TASK,
    'weight' => -8,
    'file' => 'category.admin.inc',
  );
  $items['admin/content/category/%'] = array(
    'title' => 'List categories',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('category_overview_categories', 3),
    'access arguments' => array('administer categories'),
    'type' => MENU_CALLBACK,
    'file' => 'category.admin.inc',
  );

  $items['admin/content/category/%/list'] = array(
    'title' => 'List',
    'type' => MENU_DEFAULT_LOCAL_TASK,
    'weight' => -10,
  );
  $items['admin/content/category/%/add'] = array(
    'title' => 'Add category',
    'page callback' => 'category_add_category_page',
    'page arguments' => array(3),
    'access arguments' => array('administer categories'),
    'type' => MENU_LOCAL_TASK,
    'weight' => -9,
    'file' => 'category.admin.inc',
  );

  $items['category/%'] = array(
    'title' => 'Category listing',
    'page callback' => 'category_page',
    'page arguments' => array(1),
    'access arguments' => array('access content'),
    'type' => MENU_CALLBACK,
    'file' => 'category.pages.inc',
  );
  $items['node/%/feed'] = array(
    'title' => 'RSS feed',
    'page callback' => 'category_feed',
    'page arguments' => array(1),
    'access arguments' => array('access content'),
    'type' => MENU_CALLBACK,
    'file' => 'category.pages.inc',
  );

  $items['category/wrapper'] = array(
    'title' => 'Category wrapper',
    'page callback' => 'category_wrapper',
    'access arguments' => array('administer categories'),
    'type' => MENU_CALLBACK,
    'file' => 'category.pages.inc',
  );
  $items['category/autocomplete'] = array(
    'title' => 'Autocomplete category',
    'page callback' => 'category_autocomplete',
    'access arguments' => array('access content'),
    'type' => MENU_CALLBACK,
    'file' => 'category.pages.inc',
  );
  $items['category/js/form'] = array(
    'page callback' => 'category_form_update',
    'access arguments' => array('access content'),
    'type' => MENU_CALLBACK,
    'file' => 'category.pages.inc',
  );
  $items['category/js/distant/%/%'] = array(
    'page callback' => 'category_distant_update',
    'page arguments' => array(3, 4),
    'access arguments' => array('access content'),
    'type' => MENU_CALLBACK,
    'file' => 'category.pages.inc',
  );

  return $items;
}

/**
 * Implementation of hook_init(). Add's the category module's CSS.
 */
function category_init() {
  drupal_add_css(drupal_get_path('module', 'category') .'/category.css');
  require_once dirname(drupal_get_filename('module', 'category')) .'/category.inc';
}

/**
 * Implementation of hook_form_alter().
 *
 * Adds the category or container fieldset to the node form.
 *
 * Also generates a form for selecting categories to associate with a node.
 * We check for category_override_selector before loading the full
 * category list, so contrib modules can intercept before hook_form_alter
 *  and provide scalable alternatives.
 */
function category_form_alter(&$form, $form_state, $form_id) {
  // Category node type behavior settings.
  if ($form_id == 'node_type_form' && isset($form['identity']['type'])) {
    $default_behavior = variable_get('category_behavior_'. $form['#node_type']->type, 0);
    if ($default_behavior === 'container' || $default_behavior === 0) {
      drupal_add_js("if (Drupal.jsEnabled) { $(document).ready(function() { $('div.form-item:has(div.category-allowed-containers)').css('display', 'none'); }); }", 'inline');
    }
    drupal_add_js("if (Drupal.jsEnabled) { $(document).ready(function() { $('input.category-behavior').click(function() {if ( this.value == 'category') { $('div.form-item:has(div.category-allowed-containers)').show('fast'); } else { $('div.form-item:has(div.category-allowed-containers)').hide('fast'); } }); }); }", 'inline');
    $form['category'] = array(
      '#type' => 'fieldset',
      '#title' => t('Category settings'),
      '#collapsible' => TRUE,
      '#collapsed' => TRUE,
    );
    $behavior_disabled = FALSE;
    $existing_nodes = 0;
    if (!empty($default_behavior)) {
      if ($existing_nodes = db_result(db_query("SELECT COUNT(c.cid) AS cid_count FROM {category} c INNER JOIN {node} n ON c.cid = n.nid WHERE n.type = '%s'", $form['#node_type']->type))) {
        $behavior_disabled = TRUE;
      }
    }
    $behavior_options = array(
      0 => t('None'),
      'category' => t('Category'),
      'container' => t('Container'),
    );
    $count_message = format_plural($existing_nodes, t(' <strong>Note:</strong> this node type is already a @type, and there is %count node of this type that has corresponding @type information. You cannot change the behavior of this node type unless you delete the existing node.', array('@type' => drupal_strtolower($behavior_options[$default_behavior]), '%count' => $existing_nodes)), t(' <strong>Note:</strong> this node type is already a @type, and there are %count nodes of this type that have corresponding @type information. You cannot change the behavior of this node type unless you delete all of these nodes.', array('@type' => drupal_strtolower($behavior_options[$default_behavior]), '%count' => $existing_nodes)));
    $form['category']['category_behavior'] = array(
      '#type' => 'radios',
      '#title' => t('Behavior'),
      '#default_value' => $default_behavior,
      '#required' => TRUE,
      '#options' => $behavior_options,
      '#description' => t('Attaches category or container behavior to this node type.') . ($behavior_disabled ? $count_message : ''),
      '#attributes' => array('class' => 'category-behavior'),
      '#disabled' => $behavior_disabled,
    );
    $form['category']['category_allowed_containers'] = array(
      '#type' => 'checkboxes',
      '#title' => t('Allowed containers'),
      '#default_value' => variable_get('category_allowed_containers_'. $form['#node_type']->type, array()),
      '#options' => _category_allowed_containers_options(),
      '#description' => t('Applies only if this content type has its behavior set to \'category\'. If so, this specifies the containers that categories of this content type may belong to. Leave all options un-checked to allow all containers.'),
      '#attributes' => array('class' => 'category-allowed-containers'),
    );
  }

  // Category / container node add / edit form elements.
  if (isset($form['type']) && isset($form['#node']) && $form['type']['#value'] .'_node_form' == $form_id) {
    // Add elements to the node form
    $node = $form['#node'];

    if (isset($node->category)) {
      $form['#submit'][] = 'category_node_form_submit';
      _category_add_form_elements($form, $node);
      $form['category']['hierarchy']['pick-container'] = array(
        '#type' => 'submit',
        '#value' => t('Change container (update list of parents)'),
         // Submit the node form so the parent select options get updated.
         // This is typically only used when JS is disabled.  Since the parent options
         // won't be changed via AJAX, a button is provided in the node form to submit
         // the form and generate options in the parent select corresponding to the
         // selected book.  This is similar to what happens during a node preview.
        '#submit' => array('node_form_submit_build_node'),
        '#weight' => 5,
      );
    }
  }

  // Category selection form elements.
  if (isset($form['type']) && isset($form['#node']) && (!variable_get('category_override_selector', FALSE)) && $form['type']['#value'] .'_node_form' == $form_id) {
    $node = $form['#node'];

    if (!isset($node->categories)) {
      $categories = array();
      if (!empty($node->nid)) {
        $categories = category_node_get_categories($node);
      }
      else if (arg(0) == 'node' && arg(1) == 'add' && is_numeric(arg(3))) {
        $categories[arg(3)] = category_get_category(arg(3));
      }
    }
    else {
      // After preview the categories must be converted to objects.
      if (isset($form_state['node_preview'])) {
        $node->categories = category_preview_categories($node);
      }
      $categories = $node->categories;
    }

    $c = db_query(db_rewrite_sql("SELECT n.nid, n.title, cn.*, c.weight FROM {category_cont} cn INNER JOIN {category_cont_node_types} nt ON cn.cid = nt.cid INNER JOIN {category} c ON cn.cid = c.cid INNER JOIN {node} n ON cn.cid = n.nid WHERE nt.type = '%s' ORDER BY c.weight, n.title", 'n', 'nid'), $node->type);
    $containers = array();
    $container_map = array();
    $weight_offset = 0;

    // Build list of non-free-tagging containers, all of which are
    // candidates for AJAX distant-parent behavior.
    while ($container = db_fetch_object($c)) {
      $containers[] = $container;
      end($containers);
      $container_map[$container->cid] = key($containers);
    }

    foreach ($containers as $key => $container) {
      if ($container->tags) {
        if (isset($form_state['node_preview'])) {
          // Typed string can be changed by the user before preview,
          // so we just insert the tags directly as provided in the form.
          $typed_string = $node->categories['tags'][$container->cid];
        }
        else {
          $typed_string = category_implode_tags($categories, $container->cid) . (array_key_exists('tags', $categories) ? $categories['tags'][$container->cid] : NULL);
        }
        if ($container->help) {
          $help = $container->help;
        }
        else {
          $help = t('A comma-separated list of categories describing this content. Example: funny, bungee jumping, "Company, Inc.".');
        }
        $form['categories']['tags'][$container->cid] = array(
          '#type' => 'textfield',
          '#title' => $container->title,
          '#description' => $help,
          '#required' => $container->required,
          '#default_value' => $typed_string,
          '#autocomplete_path' => 'category/autocomplete/'. $container->cid,
          '#weight' => $container->weight,
          '#maxlength' => 255,
        );
      }
      else {
        // Extract categories belonging to the container in question.
        $default_categories = array();
        foreach ($categories as $category) {
          // Free tagging has no default categories and also no container id after preview.
          if (isset($category->cnid) && $category->cnid == $container->cid) {
            $default_categories[$category->cid] = $category;
          }
        }
        if (empty($default_categories)) {
          $default_categories = array(0);
        }

        $parents = NULL;
        // Find the default categories for the parent of this container -
        // needed only for AJAX distant parent selection.
        if (!empty($container->allowed_parent)) {
          if (isset($containers[$container_map[$container->allowed_parent]])) {
            $parent_cnid = $containers[$container_map[$container->allowed_parent]]->cid;
            $parents_array = array();
            foreach ($categories as $category) {
              if (isset($category->cnid) && $category->cnid == $parent_cnid) {
                $parents_array[] = $category->cid;
              }
            }

            $parents = $parents_array;
          }
        }

        $form['categories'][$container->cid] = category_form($container->cid, array_keys($default_categories), $container->help, 'category', $parents);
        // Weight offset is used to leave 'extra room' between select elements,
        // so that submit buttons can be added where necessary (for AJAX
        // distant parent containers).
        if ($weight_offset) {
          $weight_offset *= 2;
        }
        $form['categories'][$container->cid]['#weight'] = (!empty($container->weight) ? $container->weight : 0) + $weight_offset;
        if (!$weight_offset) {
          $weight_offset = 1;
        }
        $form['categories'][$container->cid]['#required'] = TRUE;
      }
    }
    if (!empty($form['categories']) && is_array($form['categories'])) {
      if (count($form['categories']) > 1) {
        // Add fieldset only if form has more than 1 element.
        $form['categories'] += array(
          '#type' => 'fieldset',
          '#title' => t('Categories'),
          '#collapsible' => TRUE,
          '#collapsed' => FALSE,
        );
      }
      $form['categories']['#weight'] = -3;
      $form['categories']['#tree'] = TRUE;
    }

    for ($curr = 0; $curr < count($containers); $curr++) {
      for ($cand = 0; $cand < count($containers); $cand++) {
        if (!empty($containers[$cand]->allowed_parent) && $containers[$cand]->allowed_parent == $containers[$curr]->cid) {
          // For any pair of container select lists on this form where one
          // container has another as its distant parent, add an AHAH callback
          // to the parent, and add a wrapper div to the child.
          // NOTE: this will fail in cases where multiple containers share a
          // single distant parent. In such cases, the AHAH behavior will only
          // apply to the first child container. This is because Drupal's AHAH
          // framework does not support affecting multiple elements in a single
          // callback.
          if (!isset($form['categories'][$containers[$curr]->cid]['#ahah'])) {
            $form['categories'][$containers[$curr]->cid] += array(
              '#ahah' => array(
                'path' => 'category/js/distant/'. $containers[$curr]->cid .'/'. $containers[$cand]->cid,
                'wrapper' => 'edit-category-'. $containers[$cand]->cid .'-wrapper',
                'effect' => 'slide',
              ),
            );

            $form['categories'][$containers[$cand]->cid] += array(
              '#prefix' => '<div id="edit-category-'. $containers[$cand]->cid .'-wrapper" class="category-distant-wrapper">',
              '#suffix' => '</div>',
            );

            $form['categories'][$containers[$curr]->cid .'-pick'] = array(
              '#type' => 'submit',
              '#value' => t('Update children of @parent', array(
                '@parent' => $containers[$curr]->title)
              ),
               // Submit the node form so the child select options get updated.
               // This is typically only used when JS is disabled.  Since the child options
               // won't be changed via AJAX, a button is provided in the node form to submit
               // the form and generate options in the child select corresponding to the
               // appropriate container.  This is similar to what happens during a node preview.
              '#submit' => array('node_form_submit_build_node'),
              '#weight' => $form['categories'][$containers[$curr]->cid]['#weight'] + 1,
            );

            // Need this for AJAX.
            if (!isset($form['categories']['#cache'])) {
              $form['categories']['#cache'] = TRUE;
            }
            drupal_add_js("if (Drupal.jsEnabled) { $(document).ready(function() { $('#edit-categories-". $containers[$curr]->cid ."-pick').css('display', 'none'); }); }", 'inline');
          }
        }
      }
    }
  }
}

/**
 * Additional form submit handler for category/container node forms.
 *
 * Flattens and processes the $form_state['values']['category'] array
 * on both submits and previews. This is needed because
 * the 'category' fieldset on the node form has to be 'tree = TRUE', but
 * we don't want to deal with the fieldset hierarchy all the time.
 */
function category_node_form_submit($form, &$form_state) {
  $fieldsets = array(
    'hierarchy' => TRUE,
    'advanced' => TRUE,
    'identification' => TRUE,
    'content_types' => TRUE,
    'tagging' => TRUE,
    'distant' => TRUE,
  );
  foreach ($form_state['values']['category'] as $key => $value) {
    if (isset($fieldsets[$key]) && is_array($value)) {
      $form_state['values']['category'] += $value;
      unset($form_state['values']['category'][$key]);
    }
  }

  if (!empty($form_state['values']['category']['cid']) && $form_state['values']['category']['cid'] == 'new') {
    unset($form_state['values']['category']['cid']);
  }

  // Load the new parent for distant-parent category selection.
  if (!empty($form_state['values']['op'])) {
    $containers = category_get_containers($node->type);
    $is_valid_submission = FALSE;
    foreach ($containers as $container) {
      if ($form_state['values']['op'] == t('Update children of @parent', array('@parent' => $container->title))) {
        $is_valid_submission = TRUE;
      }
    }

    if ($is_valid_submission) {
      foreach ($containers as $container) {
        if (!empty($form_state['values']['categories'][$container->cid])) {
          $post_categories = $form_state['values']['categories'][$container->cid];
          if (!is_array($post_categories)) {
            if (is_numeric($post_categories)) {
              $post_categories = (int) $post_categories;
              $node->categories[$post_categories] = category_get_category($post_categories);
            }
          }
          else {
            foreach ($post_categories as $post_category) {
              if (is_numeric($post_category)) {
                $post_category = (int) $post_category;
                $node->categories[$post_category] = category_get_category($post_category);
              }
            }
          }
        }
      }
    }
  }
}

/**
 * Generate a form element for selecting categories from a container.
 */
function category_form($cnid, $value = 0, $help = NULL, $name = 'category',
$parents = NULL) {
  $container = category_get_container($cnid);
  $help = ($help) ? $help : $container->help;

  if (!$container->multiple) {
    $blank = ($container->required) ? t('- Please choose -') : t('- None selected -');
  }
  else {
    $blank = ($container->required) ? 0 : t('- None -');
  }

  return _category_category_select(check_plain($container->title), $name, $value, $cnid, $help, intval($container->multiple), $blank, array(), $parents);
}

/**
 * Helper function to convert categories after a preview.
 *
 * After preview the tags are an array instead of proper objects. This function
 * converts them back to objects with the exception of 'free tagging' categories,
 * because new tags can be added by the user before preview and those do not
 * yet exist in the database. We therefore save those tags as a string so
 * we can fill the form again after the preview.
 */
function category_preview_categories($node) {
  $categories = array();
  if (isset($node->categories)) {
    foreach ($node->categories as $key => $category) {
      unset($node->categories[$key]);
      // A 'Multiple select' and a 'Free tagging' field returns an array.
      if (is_array($category)) {
        foreach ($category as $cid) {
          if ($key == 'tags') {
            // Free tagging; the values will be saved for later as strings
            // instead of objects to fill the form again.
            $categories['tags'] = $category;
          }
          else {
            $categories[$cid] = category_get_category($cid);
          }
        }
      }
      // A 'Single select' field returns the category id.
      elseif ($category) {
        $categories[$category] = category_get_category($category);
      }
    }
  }
  return $categories;
}

/**
 * Provides category information for rss feeds.
 */
function category_rss_item($node) {
  $output = array();
  foreach ($node->categories as $cat) {
    $is_included = TRUE;
    if (module_exists('category_display')) {
      $cont = category_display_get_container($cat->cnid);
      if (!$cont->nodelinks) {
        $is_included = FALSE;
      }
    }

    if ($is_included) {
      $output[] = array(
        'key'   => 'category',
        'value' => check_plain($cat->title),
        'attributes' => array(
          'domain' => url('node/'. $cat->cid, array('absolute' => TRUE))
        ),
      );
    }
  }
  return $output;
}

/**
 * Make sure incoming cnids are free tagging enabled.
 */
function category_node_validate(&$node) {
  if (!empty($node->categories)) {
    $categories = $node->categories;
    if (!empty($categories['tags'])) {
      foreach ($categories['tags'] as $cnid => $cnid_value) {
        $container = category_get_container($cnid);
        if (empty($container->tags)) {
          // see form_get_error $key = implode('][', $element['#parents']);
          // on why this is the key
          form_set_error("categories][tags][$cnid", t('The %title container can not be modified in this way.', array('%title' => $container->title)));
        }
      }
    }
    else {
      foreach ($categories as $cnid => $category) {
        if (empty($category)) {
          $container = category_get_container($cnid);
          if ($container->required) {
            form_set_error("categories][$cnid", t('You must choose a category from %container.', array('%container' => $container->title)));
          }
        }
      }
    }
  }
}

/**
 * Save category associations for a given node.
 */
function category_node_save($node, $categories) {
  global $user;

  category_node_delete_revision($node);

  // Free tagging containers do not send their cids in the form,
  // so we'll detect them here and process them independently.
  if (isset($categories['tags'])) {
    $typed_input = $categories['tags'];
    unset($categories['tags']);

    foreach ($typed_input as $cnid => $cnid_value) {
      $typed_cats = drupal_explode_tags($cnid_value);

      $inserted = array();
      foreach ($typed_cats as $typed_cat) {
        // See if the term exists in the chosen container
        // and return the cid, otherwise, add a new record.
        $possibilities = category_get_category_by_name($typed_cat);
        $typed_cat_cid = NULL; // cid match if any.
        foreach ($possibilities as $possibility) {
          if ($possibility->cnid == $cnid) {
            $typed_cat_cid = $possibility->cid;
          }
        }

        if (!$typed_cat_cid) {
          $tag_node = new stdClass();
          $tag_node->title = $typed_cat;
          $tag_node->type = 'category';
          $tag_node->category['cnid'] = $cnid;
          $tag_node->category['parents'][0] = $cnid;
          $node_options = variable_get('node_options_'. $tag_node->type, array('status', 'promote'));
          $tag_node->status = in_array('status', $node_options);
          $tag_node->promote = in_array('promote', $node_options);
          $tag_node->sticky = in_array('sticky', $node_options);
          $tag_node->revision = in_array('revision', $node_options);
          $tag_node->name = $user->name ? $user->name : 0;
          $tag_node->date = date('j M Y H:i:s');
          $tag_node = node_submit($tag_node);
          node_save($tag_node);
          $typed_cat_cid = $tag_node->nid;
        }

        // Defend against duplicate, differently cased tags
        if (!isset($inserted[$typed_cat_cid])) {
          db_query('INSERT INTO {category_node} (nid, vid, cid) VALUES (%d, %d, %d)', $node->nid, $node->vid, $typed_cat_cid);
          $inserted[$typed_cat_cid] = TRUE;
        }
      }
    }
  }

  if (is_array($categories)) {
    foreach ($categories as $key => $cat) {
      if ($key != 'tags') {
        if (is_array($cat)) {
          foreach ($cat as $cid) {
            if (!empty($cid)) {
              db_query('INSERT INTO {category_node} (nid, vid, cid) VALUES (%d, %d, %d)', $node->nid, $node->vid, $cid);
            }
          }
        }
        else if (isset($cat->cid)) {
          db_query('INSERT INTO {category_node} (nid, vid, cid) VALUES (%d, %d, %d)', $node->nid, $node->vid, $cat->cid);
        }
        else if ($cat) {
          db_query('INSERT INTO {category_node} (nid, vid, cid) VALUES (%d, %d, %d)', $node->nid, $node->vid, $cat);
        }
      }
    }
  }
}

/**
 * Remove associations of a node to its categories.
 */
function category_node_delete($node) {
  db_query('DELETE FROM {category_node} WHERE nid = %d', $node->nid);
  category_cache_op('flush', $node->nid);
}

/**
 * Remove associations of a node to its terms.
 */
function category_node_delete_revision($node) {
  db_query('DELETE FROM {category_node} WHERE vid = %d', $node->vid);
  category_cache_op('flush', $node->nid);
}

/**
 * Implementation of hook_node_type().
 */
function category_node_type($op, $info) {
  if ($op == 'update' && !empty($info->old_type) && $info->type != $info->old_type) {
    db_query("UPDATE {category_cont_node_types} SET type = '%s' WHERE type = '%s'", $info->type, $info->old_type);

    $allowed_containers = variable_get('category_allowed_containers_'. $info->old_type, array());
    variable_del('category_allowed_containers_'. $info->old_type);
    if (!empty($allowed_containers)) {
      variable_set('category_allowed_containers_'. $info->type, $allowed_containers);
    }

    $behavior = variable_get('category_behavior_'. $info->old_type, 0);
    variable_del('category_behavior_'. $info->old_type);
    if (!empty($behavior)) {
      variable_set('category_behavior_'. $info->type, $behavior);
    }
  }
  elseif ($op == 'delete') {
    db_query("DELETE FROM {category_cont_node_types} WHERE type = '%s'", $info->type);
    variable_del('category_allowed_containers_'. $info->type);
    variable_del('category_behavior_'. $info->type);
  }
}

/**
 * Implementation of hook_nodeapi().
 *
 * Handles category loading, inserting and updating.
 */
function category_nodeapi(&$node, $op, $teaser, $page) {
  switch ($op) {
    case 'load':
      $output = array();
      $behavior = variable_get('category_behavior_'. $node->type, 0);
      if (!empty($behavior)) {
        if ($behavior == 'category') {
          $output['category'] = (array) category_get_category($node->nid);
        }
        else {
          $output['category'] = (array) category_get_container($node->nid);
        }
        $output['category']['parents'] = category_get_parents($node->nid);
        $output['category']['behavior'] = $behavior;
      }
      $output['categories'] = category_node_get_categories($node);
      return $output;

    case 'view':
      if (!$teaser) {
        $behavior = variable_get('category_behavior_'. $node->type, 0);
        if (isset($behavior) && $node->build_mode == NODE_BUILD_NORMAL && ($listing = category_node_listing($node))) {
          $node->content['category_listing'] = array(
            '#value' => $listing,
            '#weight' => 100,
          );
        }
      }
      break;

    case 'prepare':
      $behavior = variable_get('category_behavior_'. $node->type, 0);
      if (!empty($behavior)) {
        // Prepare defaults for the add/edit form.
        if (empty($node->category)) {
          $node->category = array();
          if (empty($node->nid) && isset($_GET['parent']) &&
          is_numeric($_GET['parent'])) {
            // Handle "Add child page" links:
            $parent = category_get_category($_GET['parent']);
            if (!empty($parent)) {
              $cnid = !empty($parent->cnid) ? $parent->cnid : $parent->cid;
              $parent_container = category_get_container($cnid);
              $allowed_containers = variable_get('category_allowed_containers_'. $node->type, array());
              if (empty($parent->category['allowed_parent'])) {
                $node->category['container'] = $cnid;
              }
              else {
                $allowed_key = array_search(
                $parent->category['allowed_parent'], $allowed_containers);
                $node->category['container'] = ($allowed_key !== FALSE) ? $allowed_containers[$allowed_key] : $cnid;
              }
              $node->category['parents'] = array($parent->nid => $parent->nid);
            }
          }
          if (isset($node->category['container']) && !isset($node->category['original_container'])) {
            $node->category['original_container'] = $node->category['container'];
          }
          // Set defaults.
          $node->category += _category_defaults(!empty($node->nid) ? $node->nid : 'new');
        }
        else {
          $node->category['container'] = empty($node->category['container']) ? $node->category['cnid'] : $node->category['container'];
          if (empty($node->category['container']) && !empty($node->category['parents']) && $behavior == 'container') {
            reset($node->category['parents']);
            $first_parent = current($node->category['parents']);
            $node->category['container'] = (!empty($first_parent->cnid) ? $first_parent->cnid : $first_parent->cid);
          }
          if (isset($node->category['container']) && !isset($node->category['original_container'])) {
            $node->category['original_container'] = $node->category['container'];
          }
        }
        // Find the depth limit for the parent select.
        if (isset($node->category['container']) && !isset($node->category['parent_depth_limit'])) {
          $node->category['parent_depth_limit'] = (MENU_MAX_DEPTH - 1);
        }
        $node->category['behavior'] = $behavior;
      }
      break;

    case 'insert':
    case 'update':
      $behavior = variable_get('category_behavior_'. $node->type, 0);
      if (!empty($behavior)) {
        if ($behavior == 'category') {
          category_save_category($node);
        }
        else {
          category_save_container($node);
        }
      }

      if (!empty($node->categories)) {
        category_node_save($node, _category_filter_pick_elements($node->categories));
      }
      break;

    case 'delete':
      $behavior = variable_get('category_behavior_'. $node->type, 0);
      if (!empty($behavior)) {
        if ($behavior == 'category') {
          category_del_category($node->nid);
        }
        else {
          category_del_container($node->nid);
        }
      }

      category_node_delete($node);
      break;

    case 'delete revision':
      category_node_delete_revision($node);
      break;

    case 'validate':
      category_node_validate($node);
      break;

    case 'rss item':
      return category_rss_item($node);

    case 'update index':
      return category_node_update_index($node);
  }
}

/**
 * Implementation of hook_nodeapi('update_index').
 */
function category_node_update_index(&$node) {
  $output = array();
  if (!empty($node->category)) {
    foreach ($node->category as $cat) {
      $output[] = $cat->title;
    }
  }
  if (count($output)) {
    return '<strong>('. implode(', ', $output) .')</strong>';
  }
}

/**
 * A recursive helper function for category_toc().
 */
function _category_toc_recurse($tree, $indent, &$toc, $exclude, $depth_limit) {
  foreach ($tree as $data) {
    if (($data->depth + 1) > $depth_limit) {
      // Don't iterate through any links on this level.
      break;
    }
    if (!in_array($data->cid, $exclude)) {
      $toc[$data->cid] = str_repeat($indent, $data->depth + 1) .' '. truncate_utf8($data->title, 30, TRUE, TRUE);
    }
  }
}

/**
 * Returns an array of container children in table of contents order.
 *
 * @param $container
 *   The ID of the container whose children are to be listed.
 * @param $exclude
 *   Optional array of nid values.  Any category whose nid is in this array
 *   will be excluded (along with its children).
 * @param $depth_limit
 *   Any category deeper than this value will be excluded (along with its children).
 * @return
 *   An array of nid, title pairs for use as options for selecting a category.
 */
function category_toc($container, $exclude = array(), $depth_limit) {
  $tree = category_get_tree($container);
  $container = category_get_container($container);
  if (!in_array($container->cid, $exclude)) {
    $toc[$container->cid] = $container->title;
  }
  _category_toc_recurse($tree, '--', $toc, $exclude, $depth_limit);

  return $toc;
}

/**
 * Saves a container to the database. This function is called when node_save()
 * is run on a node that has container behavior.
 */
function category_save_container(&$node) {
  $new = empty($node->category['cid']);
  $node->category['cid'] = $node->nid;
  $node->category['cnid'] = 0;
  $node->category['nodes'] = empty($node->category['nodes']) ? array() : $node->category['nodes'];

  if (!isset($node->category['module'])) {
    $node->category['module'] = 'category';
  }
  if (!empty($node->category['parents']) && !is_array($node->category['parents'])) {
    $node->category['parents'] = array($node->category['parents'] => TRUE);
  }
  if (empty($node->category['parents'])) {
    $node->category['parents'] = array(0 => TRUE);
  }

  if ($new) {
    // Insert new.
    drupal_write_record('category', $node->category);
    drupal_write_record('category_cont', $node->category);
    $status = SAVED_NEW;
  }
  else {
    drupal_write_record('category', $node->category, 'cid');
    drupal_write_record('category_cont', $node->category,