pwolanin/test/outline.module

<?php
// $Id: outline.module,v 1.1 2007/01/16 03:04:41 pwolanin Exp $

/**
 * @file
 * A module to enable nodes to be organized into a hierarchical outline
 *
 * An outline is a set of pages tied together in sequence, with links and menus to 
 * guide users from section to section or to the previous page or the next.
 * Users can collaborate in writing the outline, reviewing or modifying the pages, 
 * and putting them in the right order.
 */

/**
 * Implementation of hook_perm().
 */
function outline_perm() {
    return array('outline posts', 'create new outlines', 'see printer-friendly version');
}

/**
 * Implementation of hook_link().
 */
function outline_link($type, $node = NULL, $teaser = FALSE) {

  $links = array();
  if ($type == 'node' && isset($node->outid)) {
    if (!$teaser) { 
      $child_type  = $node->child_type; 
      if (node_access('create', $child_type)) {
        $type_url = str_replace('_', '-', $child_type);
        $links['outline_add_child'] = array(
          'title' => t('Add child page'),
          'href' => "node/add/". $type_url,
          'query' => 'parent='. $node->nid,
        );
      }   
      if (user_access('see printer-friendly version')) {
        $links['outline_printer'] = array(
          'title' => t('Printer-friendly version'),
          'href' => 'outline/export/html/'. $node->nid,
          'attributes' => array('title' => t('Show a printer-friendly version of this page and its sub-pages in the outline.'))
        );
      }
    }
  }
  return $links;
}

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

    $items['admin/content/outline'] = array(
      'title' => t('Outlines'),
      'description' => t("Manage site's outlines and orphaned outline pages."),
      'page callback' => 'outline_admin',
      'access arguments' => 'administer nodes');
    $items['admin/content/outline/list'] = array(
      'title' => t('List'),
      'type' => MENU_DEFAULT_LOCAL_TASK);
    $items['admin/content/outline/orphan'] = array(
      'title' => t('Orphan pages'),
      'page callback' => 'drupal_get_form',
      'page arguments' => array('outline_admin_orphan'),
      'type' => MENU_LOCAL_TASK,
      'weight' => 5);
     $items['admin/content/outline/settings'] = array(
      'title' => t('Outline settings'),
      'page callback' => 'drupal_get_form',
      'page arguments' => array('outline_admin_settings'),
      'weight' => 8,
      'type' => MENU_LOCAL_TASK);
    $items['outline'] = array(
      'title' => t('Outlines'),
      'page callback' => 'outline_list',
      'type' => MENU_NORMAL_ITEM,
      'access arguments' => 'access content');
    $items['outline/export'] = array(
      'page callback' => 'outline_export',
      'access arguments' => 'see printer-friendly version',
      'type' => MENU_CALLBACK);


    $items['node/%node/outline'] = array(
      'title' => t('Outline'),
      'page callback' => 'outline_node',
      'page arguments' => array(1),
      'access callback' => '_outline_node_access',
      'access arguments' => array(1),//'outline posts',
      'type' => MENU_LOCAL_TASK,
      'weight' => 2);

  return $items;
}

function _outline_node_access($node) {
  return user_access('outline posts') && node_access('view', $node);
}

/**
 * Implementation of hook_init().
 */
function outline_init() {
    // Add the CSS for this module
    drupal_add_css(drupal_get_path('module', 'outline') .'/outline.css');
}


/**
 * Implementation of hook_block().
 *
 * The navigation block displays the outline table of contents in a block when the
 * current page is a single-node view a node that's in the outline hierarchy. 
 */
function outline_block($op = 'list', $delta = 0) {
  $block = array();
  if ($op == 'list') {
    $block['navigation']['info'] = t('Outline navigation');
    return $block;
  }
  elseif ($op == 'view') {
    // Outline navigation block. Only display this block when the user is
    // browsing a node in the outline hierarchy
    if (arg(0) == 'node' && is_numeric(arg(1))) {
      $this_node = node_load(arg(1));
      if (!empty($this_node->outid)) {          
        $path = outline_location($this_node);
        $path[] = $this_node;
   
        $expand = array();
        foreach ($path as $key => $node) {
          $expand[] = $node->nid;
        }
        $block['content'] = outline_page_menu_tree($this_node->outid,$path[0]->nid, 5, $expand);
        $block['subject'] = check_plain($path[0]->title);
      }
    }
    return $block;
  }
}
  

/**
 * Menu callback: change outline module administrative settings
 */
function outline_admin_settings() {  

  $form['toc_default_depth'] = array(
  '#type' => 'select',
  '#title' => t('Default depth for table of contents display for posts newly added to an outline.'),
  '#default_value' => variable_get('toc_default_depth', 5),
  '#options' => drupal_map_assoc(array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 30)),
   );

  $form['#redirect'] = "admin/content/outline";
  
  return system_settings_form($form);
}

/**
 * Helper function: generate a form for setting the page's options
 */
function _outline_options_form($node, &$form, $collapsed = TRUE) {

  $access = user_access('outline posts') || user_access('administer nodes');

  $form['outline_options'] = array(
    '#type' => 'fieldset',
    '#title' => t('Outline options'),
    '#weight' => 30,
    '#collapsible' => $collapsed && $access,
    '#collapsed' => $collapsed,
  );
  $form['outline_options']['weight'] = array(
    '#type' => 'weight',
    '#title' => t('Weight'),
    '#default_value' => (isset($node->weight) ? $node->weight : 0),
    '#delta' => 15,
    '#description' => t('Pages at a given level are ordered first by weight and then by title.'),
    '#access' => TRUE,
  );

  $types = node_get_types();
  $options = array();
  foreach ($types as $nt) {
    $options[$nt->type] = $nt->name;
  }
  $form['outline_options']['child_type'] = array(
    '#type' => 'select',
    '#title' => t('Content type for child pages'),
    '#default_value' => ($node->child_type ? $node->child_type : $node->type),
    '#options' => $options,
    '#access' =>   $access,
  );
  $form['outline_options']['toc_depth'] = array(
    '#type' => 'select',
    '#title' => t('Preferred depth for table of contents display'),
    '#default_value' => (!empty($node->toc_depth) ? $node->toc_depth : variable_get('toc_default_depth', 1)),
    '#options' => drupal_map_assoc(array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 30)),
    '#description' => t('The table of contents on the outline page will be displayed to this depth (depending upon your theme).'),
    '#access' =>   $access,
  );
}

/**
 * Helper function: generate a form for setting the parent
 */
function _outline_parent_form($node, &$form) {

  $exclude = array();
  
  if (array_key_exists($node->outid, $all_outlines = _list_outlines())) {
    $form_parent_title = t('Position in the outline %outline', array('%outline' => $all_outlines[$node->outid]));
  }
  else {
    // Maybe an orphaned page; set a generic heading.
    $form_parent_title = t('Parent');
  }
  if (isset($node->nid)) {
    $exclude[] = $node->nid; //cannot select the current node (or its children)
  }
  
  $form['parent'] = array(
    '#type' => 'select',
    '#title' => $form_parent_title,
    '#default_value' => $node->parent,
    '#options' => outline_get_parents($exclude, $node->outid),
    '#weight' => -4,
    '#description' => t('The parent that this page belongs under. "Top level" means the highest level within this outline.'),
  );
}

  
/**
 * Helper function: return an array of available outlines as (outid => title).
 */
function _list_outlines($orderby = 'ORDER BY n.title ASC'){
  static $outlines = NULL;
  
  if (empty($outlines)) { 
    $result = db_query(db_rewrite_sql("SELECT n.nid, n.title FROM {outline_hierarchy} oh JOIN {node} n ON n.nid = oh.nid WHERE oh.parent = 0 ". $orderby));
    $outlines = array();
    while ($node = db_fetch_object($result)) {
      $outlines[$node->nid] = $node->title;
    }
  } 
  return $outlines;   
}


/**
 * Helper function: generate a select form listing available outlines.
 */
function _outline_select_form($default_outid = 0, $nid, $note = ''){

  $outlines = _list_outlines();
  if (user_access('create new outlines') && $default_outid != $nid) {
    $outlines[0] = t('New, independent outline');
  }
  $form = array();
  $form['outid'] = array(
    '#type' => 'select',
    '#title' => t('Select an outline'),
    '#default_value' => $default_outid,
    '#options' => $outlines,
    '#description' => t('Select the outline you wish to add/move your page to.'),
    '#weight' => 50,
  ); 
  $form['nid'] = array(
    '#type' => 'value',
    '#value' => $nid,
  );
  if ($note) {
    $form['note'] = array(
      '#value' => '<p>'. $note. '</p>',
      '#weight' => 52,
    );
  }
  return $form; 
}


function outline_update_form($node) {
    $form = array();
    
    if ($node->parent && $node->nid != $node->outid) {
      _outline_parent_form($node, $form);        
      $form['move_page'] = array(
        '#value' => '<h2 class="outline-form">'. t('Move this post to a different outline.'). '</h2>',
        '#weight' => 40,
      );

      $form['may_remove'] = array(
       '#value' => '<h2 class="outline-form">'. t('Remove this post from the outline.'). '</h2>'. '<p>'. t('Child pages (if any) will be orphaned; you should move them first.'). '</p>',
        '#weight' => 60,
      );
      //TODO: links to child pages
      $form['remove'] = array(
        '#type' => 'submit',
        '#value' => t('Remove from outline'),
        '#weight' => 65,
      );
    
    }
    else {
      $form['outline_heading'] = array(
        '#value' => '<p>'. t('%title is an outline.', array('%title' => $node->title)). '</p>',
        '#weight' => -10,
      );      
      $form['move_page'] = array(
        '#value' => '<h2 class="outline-form">'. t('Combine this outline with a different outline.'). '</h2>',
        '#weight' => 40,
      );
    }
    _outline_options_form($node, $form, FALSE);
    $form['update'] = array(
      '#type' => 'submit',
      '#value' => t('Update options'),
      '#weight' => 35,
    );

    $children_note = t("Note: All of this pages's children will be moved together to the new outline. If you do not wish that, please update the child pages first.");
    $form = array_merge($form,_outline_select_form($node->outid, $node->nid, $children_note));
    $form['select'] = array(
      '#type' => 'submit',
      '#value' => t('Select outline'),
      '#weight' => 55,
    );
    return $form;
}

function outline_add_form($node) {
    $form = _outline_select_form(0, $node->nid);
    $form['add_note'] = array(
      '#value' => '<h2 class="outline-form">'. t('Add this post to the selected outline.'). '</h2>',
      '#weight' => 40,
    );
    $form['add'] = array(
      '#type' => 'submit', 
      '#value' => t('Add to outline'),
      '#weight' => 55,
    );
    $form['weight'] = array (
      '#type' => 'value',
      '#value' => 0,
    );
    $form['toc_depth'] = array (
      '#type' => 'value',
      '#value' =>  variable_get('toc_default_depth', 1),
    );
    $form['#base'] = 'outline_update_form';
  return $form;
}

/**
 * Menu callback: handle all outline operations on individual nodes.
 */
function outline_node($node){
 
  drupal_set_title(check_plain($node->title));
  
  if (isset($node->outid)) { // node is already part of the outline
    return drupal_get_form('outline_update_form', $node);    
  }
  else {
    return drupal_get_form('outline_add_form', $node);
  }

}

  
/**
 * Implementation of hook_form_alter()
 */
function outline_form_alter($form_id, &$form) {
  //drupal_set_message($form_id. ' <hr />'.nl2br(print_r($form,1)));
  if ($form_id == 'node_delete_confirm') {
    $node = node_load($form['nid']['#value']);
    if (isset($node->outid)) {
      if ($node->nid == $node->outid) {
        $form['outline'] = array(
          '#value' => t('Note that all outline pages belonging to this outline (if any) will no longer be associated with any outline.'),
        );
      }
      else {
          $form['outline'] = array(
            '#value' => t('Note that child pages in the outline (if any) will be orphaned. You may want to move any child pages first.'),
          );
      }
    }
  }
  elseif (isset($form['type']) && $form['type']['#value'] .'_node_form' == $form_id) {
    $node = $form['#node']; 
    
    // looking for url like node/add/page?parent=$nid
    if (arg(1) == 'add') { 
      $parent = $_GET['parent'];
      if (!empty($parent) && is_numeric($parent)) {
        $p_node = node_load($parent);
      }
      // Only permit this method if the new node type matches the
      // selected child type of the parent.
      if (!empty($p_node) && $p_node->child_type == $node->type) { 
        // Inherit outline values from parent.
        $node->parent = $p_node->nid;
        $node->outid = $p_node->outid;
        $node->child_type = $p_node->child_type;
      }
    }

    if (isset($node->outid) && isset($node->parent)) {
      $form['outid'] = array (
        '#type' => 'value',
        '#value' => $node->outid,
      );
      if ($node->parent) { // Not an outline
        _outline_parent_form($node, $form);
      }
      _outline_options_form($node, $form, TRUE);

    }
  }
  return $form;
}


/**
 * Recursivly update each child page when moving a node to a different outline.
 * 
 * @param $parent 
 *   the nid of the parent that is being moved.
 * @param $outid 
 *   the outid (outline ID) of the outline the parent is moving to.
 * @param $children 
 *   the hierarchy of the outline that the node with nid==$parent is moving
 *   from, as generated by function outline_tree.
 */
function outline_update_children_outid($parent, $outid, &$children) { 

  if (isset($children[$parent])) {
    // TDOD - rewrite this as non-recursive using the tree array
    foreach($children[$parent] as $child) {
      outline_update_children_outid($child->nid, $outid, $children);
      db_query("UPDATE {outline_hierarchy} SET outid = %d WHERE nid = %d", $outid, $child->nid);
    }
  }
} 

/**
 * Handle outline add and update form submissions.
 */
function outline_update_form_submit($form_id, $form_values) {
  $op = $form_values['op'];
  $node = node_load($form_values['nid']);

  $node->weight = $form_values['weight'];
  $node->toc_depth = $form_values['toc_depth'];
  $orig_outid = $node->outid;
  $node->outid = $form_values['outid'];
    
  if ($op == t('Add to outline')) {
    if ($node->outid == 0) { // A new outline
      $node->parent = 0;
      $node->outid = $node->nid;
      $node->child_type = $node->type;
    }
    else {
      $node->parent = $form_values['outid'];
      $node->child_type = db_result(db_query("SELECT child_type FROM {outline_hierarchy} WHERE nid = %d", $form_values['outid']));
    }    
  }
  else {
    if ($node->outid == 0) {
      $node->parent = 0;
      $node->outid = $node->nid;
    }
    else {
      $node->parent = $form_values['parent'];
    }
    $node->child_type = $form_values['child_type'];
  }
    
  switch ($op) {
    case t('Add to outline'):
      outline_nodeapi($node, 'insert');
      drupal_set_message(t('The post has been added to the outline.').'<br />'.t('You can now update where in the outline you want to locate the post.'));
      cache_clear_all();
      return 'node/'. $node->nid. '/outline';
      break;
    case t('Update options'):
      outline_nodeapi($node, 'update');
      drupal_set_message(t('The outline has been updated.'));
      cache_clear_all();
      break;
    case t('Remove from outline'):
      outline_nodeapi($node, 'delete');
      drupal_set_message(t('The post has been removed from the outline. Child pages may have been orphaned.'));
      cache_clear_all();
      break;
    case t('Select outline'):
      if ($orig_outid != $node->outid) {
        outline_update_children_outid($node->nid, $node->outid, outline_tree($orig_outid));
        outline_nodeapi($node, 'update');
        drupal_set_message(t('The post and its children have been relocated to the choosen outline.').'<br/>'.t('You can now update where in the outline you want to locate the post.'));
        cache_clear_all();
        return 'node/'. $node->nid. '/outline';
      }
      else {
        drupal_set_message(t('You selected the outline that this post already belongs to. No changes were made.')); 
      }
      break;
  }
  
  return "node/". $node->nid;
}

/**
 * Determine the path in the outline tree from the top to the parent of the node.
 *
 * @param node 
 *   a node in the outline hierarchy for which to compute the path
 * @return 
 *   an array of nodes representing the path of from the top of 
 *   the outline to the parent of the given node. Returns an empty array if
 *   the node does not exist or is not part of a outline hierarchy.
 *
 */
function outline_location($node) {
  
  $nodes = array();
  
  $pages = pages_of_outline_by_nid($node->outid);
  if (isset($pages[$node->parent])) {
    $nodes[0]= $pages[$node->parent];
    $i = 0;
    while ($nodes[$i]->parent) {
      $nodes[] = $pages[$nodes[$i++]->parent];
    }
  }
  return array_reverse($nodes);
}

/**
 * Given a node, this function returns an array of 'outline node' objects
 * representing the path in the outline tree from the given node down to
 * the last sibling of it.
 *
 * @param $node
 *   A outline node object where the path starts.
 *
 * @return
 *   An array of outline node objects representing the path nodes from the
 *   given node. Returns an empty array if the node does not exist or
 *   is not part of a outline hierarchy or there are no siblings.
 */
 // TODO: rewrite as non-recursive
function outline_location_down($node, $nodes = array()) {
  $last_direct_child = db_fetch_object(db_query(db_rewrite_sql('SELECT n.nid, n.title, oh.parent, oh.weight FROM {node} n INNER JOIN {outline_hierarchy} oh ON n.nid = oh.nid WHERE n.status = 1 AND oh.parent = %d ORDER BY oh.weight DESC, n.title DESC'), $node->nid));
  if ($last_direct_child) {
    $nodes[] = $last_direct_child;
    $nodes = outline_location_down($last_direct_child, $nodes);
  }
  return $nodes;
}

/**
 * Fetches the node object of the previous page of the outline.
 */
function outline_prev($node) {
  // If the parent is zero, we are at the start of a outline so there is no previous.
  if ($node->parent == 0) {
    return NULL;
  }
  
  //$children = outline_tree($node->outid); TODO- use this instead

  // Previous on the same level:
  $direct_above = db_fetch_object(db_query(db_rewrite_sql("SELECT n.nid, n.title, oh.weight FROM {node} n INNER JOIN {outline_hierarchy} oh ON n.nid = oh.nid WHERE oh.parent = %d AND n.status = 1 AND (oh.weight < %d OR (oh.weight = %d AND n.title < '%s')) ORDER BY oh.weight DESC, n.title DESC"), $node->parent, $node->weight, $node->weight, $node->title));
  if ($direct_above) {
    // Get last leaf of $above.
    $path = outline_location_down($direct_above);

    return $path ? (count($path) > 0 ? array_pop($path) : NULL) : $direct_above;
  }
  else {
    // Direct parent:
    $prev = db_fetch_object(db_query(db_rewrite_sql('SELECT n.nid, n.title FROM {node} n INNER JOIN {outline_hierarchy} oh ON n.nid = oh.nid WHERE n.nid = %d AND n.status = 1'), $node->parent));
    return $prev;
  }
}

/**
 * Fetches the node object of the next page of the outline.
 */
function outline_next($node) {
  // get first direct child
  $children = outline_tree($node->outid);
  if (isset($children[$node->nid][0])) {
    return $children[$node->nid][0];
  }

  // No direct child: get next for this level or any parent in this outline.
  $path = outline_location($node); // Path to top-level node including this one's parent.
  $path[] = $node;

  while (($leaf = array_pop($path)) && count($path)) {
    $next = db_fetch_object(db_query(db_rewrite_sql("SELECT n.nid, n.title, oh.weight FROM {node} n INNER JOIN {outline_hierarchy} oh ON n.nid = oh.nid WHERE oh.parent = %d AND n.status = 1 AND (oh.weight > %d OR (oh.weight = %d AND n.title > '%s')) ORDER BY oh.weight ASC, n.title ASC"), $leaf->parent, $leaf->weight, $leaf->weight, $leaf->title));
    if ($next) {
      return $next;
    }
  }
}

/**
 * Create formatted html for the table of contents displayed on $node.
 *
 * @ingroup themeable 
 */
function theme_outline_toc($node) {
  $toc = '<div class="outline-toc"><h3>' . t('Table of contents') . '</h3>';
  $toc .= outline_page_menu_tree($node->outid, $node->nid, $node->toc_depth);
  $toc .= '</div>';
  return $toc;
}

/**
 * Implementation of hook_nodeapi().
 *
 * Handles all load/view/submit/insert/update/delete/delete revision opertions
 * necessary for outlines
 */
function outline_nodeapi(&$node, $op, $teaser = NULL, $page = NULL) {
  switch ($op) {
     case 'load': //all types in outline handled here 
      return db_fetch_array(db_query('SELECT * FROM {outline_hierarchy} WHERE nid = %d', $node->nid));
      break;
    case 'view':
      if (!$teaser) {
        // check if it is a node in the outline hierarchy:
        if (isset($node->outid)) {
          $path = outline_location($node);
          // Construct the breadcrumb:
          $node->breadcrumb = array(); // Overwrite the trail with a outline trail.
          $node->breadcrumb[] = array ('path' => 'outline', 'title' => t('outlines'));
          foreach ($path as $level) {
            $node->breadcrumb[] = array('path' => 'node/'. $level->nid, 'title' =>  $level->title);
          }
          $node->breadcrumb[] = array('path' => 'node/'. $node->nid);
          menu_set_location($node->breadcrumb);

            $node->content['outline_navigation'] = array(
              '#value' => theme('outline_page_navigation', $node),
              '#weight' => 200,
            );
          
        }
      }
      return $node;
      break;
    case 'submit':
      // Require revisions for non-administrators.
      if (isset($node->outid) && !user_access('administer nodes')) {
        $node->revision = TRUE;
      }
      break;
    case 'update':
      if (isset($node->outid)) {
        db_query("UPDATE {outline_hierarchy} SET parent = %d, weight = %d, child_type = '%s', toc_depth = %d WHERE nid = %d", $node->parent, $node->weight, $node->child_type, $node->toc_depth, $node->nid);
      }
      break;
    case 'insert':
      if (isset($node->outid)){ 
        db_query("INSERT INTO {outline_hierarchy} (nid, outid, parent, child_type, weight, toc_depth) VALUES (%d, %d, %d, '%s', %d, %d)", $node->nid, $node->outid, $node->parent, $node->child_type, $node->weight, $node->toc_depth);
      }    
      break;
    case 'delete':
      if (isset($node->outid)) {
        db_query('DELETE FROM {outline_hierarchy} WHERE nid = %d', $node->nid);
      }
      break;
  }
}

/**
 * Prepares the links to children (TOC) and forward/backward
 * navigation for a node presented as a book page.
 *
 * @ingroup themeable
 */
function theme_outline_page_navigation($node) {
  $output = '';
  $links = '';

  if ($node->nid) {
    $tree = outline_page_menu_tree($node->outid, $node->nid, $node->toc_depth);

    if ($node->parent != 0) {
      if ($prev = outline_prev($node)) {
        drupal_add_link(array('rel' => 'prev', 'href' => url('node/'. $prev->nid)));
        $links .= l(t('‹ ') . $prev->title, 'node/'. $prev->nid, array('attributes' => array('class' => 'page-previous', 'title' => t('Go to previous page'))));
      }
      drupal_add_link(array('rel' => 'up', 'href' => url('node/'. $node->parent)));
      if ($node->parent != $node->outid){
        $links .= l(t('up'), 'node/'. $node->parent, array('attributes' => array('class' => 'page-up', 'title' => t('Go to parent page'))));
      }
      else {
        $links .= l(t('up'), 'node/'. $node->outid, array('attributes' => array('class' => 'page-up', 'title' => t('Go to outline cover'))));
      }

      if ($next = outline_next($node)) {
        drupal_add_link(array('rel' => 'next', 'href' => url('node/'. $next->nid)));
        $links .= l($next->title . t(' ›'), 'node/'. $next->nid, array('attributes' => array('class' => 'page-next', 'title' => t('Go to next page'))));
      }
    }
    if ($tree || $links) {
      $output = '<div class="outline-navigation">';
      if ($tree) {
        $output .= $tree;
      }
      if ($links) {
        $output .= '<div class="page-links clear-block">'. $links .'</div>';
      }
      $output .= '</div>';
    }
  }

  return $output;
}

/**
 * Returns an array of titles and nid entries of outline pages where the array keys are the nid values
 */
function pages_of_outline_by_nid($outid) {
 static $bynid = array();
 
 if (!isset($bynid[$outid])){
   $pages= pages_of_outline($outid);
   foreach ($pages as $node) {
     $bynid[$outid][$node->nid] = $node;
   }
 }
 return $bynid[$outid];
}
   
/**
 * Returns an array of titles and nid entries of outline pages in table of contents order
 */
function pages_of_outline($outid) {
 static $outline = array();
 
 if (!isset($outline[$outid])){
   $outline[$outid] = array();
   $result = db_query(db_rewrite_sql('SELECT n.nid, n.title, oh.parent, oh.weight FROM {node} n INNER JOIN {outline_hierarchy} oh ON n.nid = oh.nid WHERE n.status = 1 AND oh.outid = %d ORDER BY oh.weight ASC, n.title ASC'), $outid);

   while ($node = db_fetch_object($result)) {
     $outline[$outid][] = $node;
   }
 }
 return $outline[$outid];
}

/**
 * Returns an array corresponding to the tree of titles and nid entries of an outline's nodes in table of contents order
 */
function outline_tree($outid) {
  static $children = array();
  
  if (!isset($children[$outid])) {
    $pages = pages_of_outline($outid);
    $children[$outid] = array();
    foreach ($pages as $node) {
      if (!isset($children[$outid][$node->parent])) {
        $children[$outid][$node->parent] = array();
      }
      $children[$outid][$node->parent][] = $node;
    }
  }
  return $children[$outid];
}

/**
 * This is a helper function for _outline_get_parents
 */
function _outline_toc_recurse($nid, $indent, $toc, &$children, $exclude) {
  if (isset($children[$nid])) {
    foreach ($children[$nid] as $node) {
      if (empty($exclude) || !in_array($node->nid, $exclude)) {
        $toc[$node->nid] = $indent .' '. $node->title;
        $toc = _outline_toc_recurse($node->nid, $indent .'--', $toc, $children, $exclude);
      }
    }
  }
  return $toc;
}

/**
 * Returns an array of titles and nid entries of outline pages in table of contents order
 * for use in a form select.
 */
function outline_get_parents($exclude = array(),  $outid) {
  
  $children = outline_tree($outid);
  $toc = array();
  if (!in_array($outid, $exclude)) {
    $toc[$outid] = '<'. t('top-level') .'>';
  }
  $toc = _outline_toc_recurse($outid, '', $toc, $children, $exclude);

  return $toc;
}

/**
 * This is a default theme display function for outline_tree()
 *
 * @ingroup themeable
 */
function theme_outline_tree_display($nid, $depth, $children, $unfold = NULL) {
  $output = '';
  if ($depth > 0) {
    if (isset($children[$nid])) {
      $output .= '<ul class="menu">';
      foreach ($children[$nid] as $node) {
        if (isset($children[$node->nid])) {
          if (empty($unfold)){
            if ($depth == 1) {
              $output .= '<li class="collapsed">'. l($node->title, 'node/'. $node->nid);
            }
            else {
              $output .= '<li class="expanded">' . l($node->title, 'node/'. $node->nid);
              $output .= theme_outline_tree_display($node->nid, $depth - 1, $children, $unfold);            
            }
          }
          else {
            if ($depth == 1 || !in_array($node->nid, $unfold)) {
              $output .= '<li class="collapsed">'. l($node->title, 'node/'. $node->nid);
            }
            else {
              $output .= '<li class="expanded">' . l($node->title, 'node/'. $node->nid);
              $output .= theme_outline_tree_display($node->nid, $depth - 1, $children, $unfold);
            }
          }
        }
        else {
          $output .= '<li class="leaf">'. l($node->title, 'node/'. $node->nid);
        }
        $output .= '</li>';
      }
      $output .= '</ul>';
    }
  }

  return $output;
}

/**
 * Returns an themed list representing the outline nodes as a tree.
 */
function outline_page_menu_tree($outid, $parent = 0, $depth = 1, $unfold = array()) {
  
  $children = outline_tree($outid);
  return theme('outline_tree_display',$parent, $depth, $children, $unfold);
}

/**
 * Menu callback; prints a listing of all outlines
 */
function outline_list() {

  $breadcrumb = array (l( t('Home'),''));
  drupal_set_breadcrumb($breadcrumb);

  $outlines = _list_outlines('ORDER BY oh.weight ASC, n.title ASC');

  $output = '';
  $items = array();
  foreach ($outlines as $nid => $title) {
    $items[] = l($title, 'node/'. $nid);
  }
  if (count($items)) {
      $output .= theme('item_list', $items);
  }

  return $output;
}

/**
 * Menu callback; Generates various representation of a outline page with
 * all descendants and prints the requested representation to output.
 *
 * The function delegates the generation of output to helper functions.
 * The function name is derived by prepending 'outline_export_' to the
 * given output type. So, e.g., a type of 'html' results in a call to
 * the function outline_export_html().
 *
 * @param type
 *   - a string encoding the type of output requested.
 *       The following types are currently supported in outline module
 *          html: HTML (printer friendly output)
 *       Other types are supported in contributed modules.
 * @param nid
 *   - an integer representing the node id (nid) of the node to export
 *
 */
function outline_export($type = 'html', $nid = 0) {
  $type = drupal_strtolower($type);
  $node_result = db_query(db_rewrite_sql('SELECT n.nid, n.title, oh.parent, oh.outid FROM {node} n INNER JOIN {outline_hierarchy} oh ON n.nid = oh.nid WHERE n.nid = %d'), $nid);
  if (db_num_rows($node_result) > 0) {
      $node = db_fetch_object($node_result);
  }
  $depth = count(outline_location($node)) + 1;
  $export_function = 'outline_export_' . $type;

  if (function_exists($export_function)) {
    print call_user_func($export_function, $nid, $depth);
  }
  else {
    drupal_set_message(t('Unknown export format.'));
    drupal_not_found();
  }
}

/**
 * This function is called by outline_export() to generate HTML for export.
 *
 * The given node is /embedded to its absolute depth in a top level
 * section/. For example, a child node with depth 2 in the hierarchy
 * is contained in (otherwise empty) &lt;div&gt; elements
 * corresponding to depth 0 and depth 1. This is intended to support
 * WYSIWYG output - e.g., level 3 sections always look like level 3
 * sections, no matter their depth relative to the node selected to be
 * exported as printer-friendly HTML.
 *
 * @param nid
 *   - an integer representing the node id (nid) of the node to export
 * @param depth
 *   - an integer giving the depth in the outline hierarchy of the node
 *     which is to be exported
 *
 * @return
 *   - string containing HTML representing the node and its children in
 *     the outline hierarchy
*/
function outline_export_html($nid, $depth) {
  if (user_access('see printer-friendly version')) {
    $node = node_load($nid);
    for ($i = 1; $i < $depth; $i++) {
      $content .= "<div class=\"section-$i\">\n";
    }
    $content .= outline_recurse($nid, $depth, 'outline_node_visitor_html_pre', 'outline_node_visitor_html_post');
    for ($i = 1; $i < $depth; $i++) {
      $content .= "</div>\n";
    }
    return theme('outline_export_html', check_plain($node->title), $content);
  }
  else {
    drupal_access_denied();
  }
}

/**
 * How the outline's HTML export should be themed
 *
 * @ingroup themeable
 */
function theme_outline_export_html($title, $content) {
  global $base_url;
  $html = "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n";
  $html .= '<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">';
  $html .= "<head>\n<title>". $title ."</title>\n";
  $html .= '<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />';
  $html .= '<base href="'. $base_url .'/" />' . "\n";
  $html .= "<style type=\"text/css\">\n@import url(misc/print.css);\n</style>\n";
  $html .= "</head>\n<body>\n". $content . "\n</body>\n</html>\n";
  return $html;
}

/**
 * Traverse the outline tree and apply functions to each node. 
 * 
 * Applies the $visit_pre() callback to each
 * node, is called recursively for each child of the node (in weight,
 * title order). Finally appends the output of the $visit_post()
 * callback to the output before returning the generated output.
 *
 * @param nid
 *  - the node id (nid) of the root node of the outline hierarchy.
 * @param depth
 *  - the depth of the given node in the outline hierarchy.
 * @param visit_pre
 *  - a function callback to be called upon visiting a node in the tree
 * @param visit_post
 *  - a function callback to be called after visiting a node in the tree,
 *    but before recursively visiting children.
 * @return
 *  - the output generated in visiting each node
 */
function outline_recurse($nid = 0, $depth = 1, $visit_pre, $visit_post) {
  $result = db_query(db_rewrite_sql('SELECT n.nid, n.title, oh.weight FROM {node} n INNER JOIN {outline_hierarchy} oh ON n.nid = oh.nid WHERE n.status = 1 AND n.nid = %d ORDER BY oh.weight ASC, n.title ASC'), $nid);
  while ($page = db_fetch_object($result)) {
    // Load the node:
    $node = node_load($page->nid);

    if ($node) {
      if (function_exists($visit_pre)) {
        $output .= call_user_func($visit_pre, $node, $depth, $nid);
      }
      else {
        $output .= outline_node_visitor_html_pre($node, $depth, $nid);
      }

      $children = db_query(db_rewrite_sql('SELECT n.nid, n.title, oh.weight FROM {node} n INNER JOIN {outline_hierarchy} oh ON n.nid = oh.nid WHERE n.status = 1 AND oh.parent = %d ORDER BY oh.weight ASC, n.title ASC'), $node->nid);
      while ($childpage = db_fetch_object($children)) {
          $childnode = node_load($childpage->nid);
          if ($childnode->nid != $node->nid) {
              $output .= outline_recurse($childnode->nid, $depth + 1, $visit_pre, $visit_post);
          }
      }
      if (function_exists($visit_post)) {
        $output .= call_user_func($visit_post, $node, $depth);
      }
      else {
        # default
        $output .= outline_node_visitor_html_post($node, $depth);
      }
    }
  }

  return $output;
}

/**
 * Generates printer-friendly HTML for a node. This function
 * is a 'pre-node' visitor function for outline_recurse().
 *
 * @param $node
 *   - the node to generate output for.
 * @param $depth
 *   - the depth of the given node in the hierarchy. This
 *   is used only for generating output.
 * @param $nid
 *   - the node id (nid) of the given node. This
 *   is used only for generating output.
 * @return
 *   - the HTML generated for the given node.
 */
function outline_node_visitor_html_pre($node, $depth, $nid) {
  // Output the content:
  $node = node_build_content($node, FALSE, FALSE);
  // Allow modules to change $node->body before viewing.
  node_invoke_nodeapi($node, 'print', $node->body, FALSE);

  $output .= "<div id=\"node-". $node->nid ."\" class=\"section-$depth\">\n";
  $output .= "<h1 class=\"outline-heading\">". check_plain($node->title) ."</h1>\n";

  if ($node->body) {
    $output .= drupal_render($node->content);
  }
  return $output;
}

/**
 * Finishes up generation of printer-friendly HTML after visiting a
 * node. This function is a 'post-node' visitor function for
 * outline_recurse().
 */
function outline_node_visitor_html_post($node, $depth) {
  return "</div>\n";
}

function _outline_admin_table($nodes = array()) {
  $form = array(
    '#theme' => 'outline_admin_table',
    '#tree' => TRUE,
  );
  
  foreach ($nodes as $node) {
    if (isset($node->outid) && ($node->nid == $node->outid)) {
      $result = db_query('SELECT nid FROM {outline_hierarchy} WHERE parent = %d AND outid = %d', $node->outid, $node->outid);
      while ($chapters = db_fetch_object($result)) {
        $chapter = node_load($chapters->nid);
        $form = array_merge($form, _outline_admin_table_tree($chapter, 0));
      }
    }
    else {
      $form = array_merge($form, _outline_admin_table_tree($node, 0));
    }
  }

  return $form;
}

function _outline_admin_table_tree($node, $depth) {
  $form = array();

  $form[] = array(
    'nid' => array('#type' => 'value', '#value' => $node->nid),
    'depth' => array('#type' => 'value', '#value' => $depth),
    'title' => array(
      '#type' => 'textfield',
      '#default_value' => $node->title,
      '#maxlength' => 255,
    ),
    'weight' => array(
      '#type' => 'weight',
      '#default_value' => $node->weight,
      '#delta' => 15,
    ),
  );

  $children = db_query(db_rewrite_sql('SELECT n.nid, oh.weight FROM {node} n INNER JOIN {outline_hierarchy} oh ON n.nid = oh.nid WHERE oh.parent = %d ORDER BY oh.weight ASC, n.title ASC'), $node->nid);
  while ($child = db_fetch_object($children)) {
    $form = array_merge($form, _outline_admin_table_tree(node_load($child->nid), $depth + 1));
  }

  return $form;
}

/**
 * Format the outline administration form.
 *
 * @ingroup themeable
 */
function theme_outline_admin_table($form) {
  $header = array(t('Title'), t('Weight'), array('data' => t('Operations'), 'colspan' => '4'));

  $rows = array();
  foreach (element_children($form) as $key) {
    $nid = $form[$key]['nid']['#value'];
    $pid = $form[0]['nid']['#value'];
    $rows[] = array(
      '<div style="padding-left: '. (25 * $form[$key]['depth']['#value']) .'px;">'. drupal_render($form[$key]['title']) .'</div>',
      drupal_render($form[$key]['weight']),
      l(t('view'), 'node/'. $nid),
</