/lib/plugins/dir/syntax.php

<?php
/**
 * Dir Plugin: Shows pages in one or namespaces in a table or list
 *
 * @license  GPL 2 (http://www.gnu.org/licenses/gpl.html)
 * @author   Jacobus Geluk <Jacobus.Geluk@gmail.com>
 * @based_on "pageindex" plugin by Kite <Kite@puzzlers.org>
 * @based_on "externallink" plugin by Otto Vainio <plugins@valjakko.net>
 * @based_on "pagelist" plugin by Esther Brunner <wikidesign@gmail.com>
 *
 * Contributions by:
 *
 * - Jean-Philippe Prade
 * - Gunther Hartmann
 * - Sebastian Menge
 */

if (! defined ('DOKU_INC')) {
  define ('DOKU_INC', realpath (dirname (__FILE__) . '/../../') . '/') ;
}
if (! defined ('DOKU_PLUGIN')) {
  define ('DOKU_PLUGIN', DOKU_INC . 'lib/plugins/') ;
}

require_once (DOKU_PLUGIN . 'syntax.php') ;
require_once (DOKU_INC . 'inc/search.php') ;

define ("DIR_PLUGIN_PATTERN", "DIR") ;
 
/**
 * The main DIR plugin class...
 */
class syntax_plugin_dir extends DokuWiki_Syntax_Plugin {
 
  var $debug           = false ;
  var $plugins         = Array () ;
  var $opts            = Array () ;
  var $cols            = Array () ;
  var $hdrs            = Array () ;
  var $pages           = Array () ;
  var $includeTags     = Array () ;
  var $excludeTags     = Array () ;
  var $hasTags         = false ;
  var $style           = "default" ;
  var $rdr             = NULL ;
  var $rdrMode         = NULL ;
  var $start           = "start" ;
  var $dformat         = NULL ;
  var $sortKeys        = Array () ;
  var $nbrOfSortKeys   = 0 ;
  var $useDefaultTitle = true ;
  var $modeIsXHTML     = false ;
  var $modeIsLatex     = false ;
  var $processedLatex  = false ;
  var $rowNumber       = 0 ;
  
  /**
   * Constructor
   */
  function syntax_plugin_dir () {
   
   global $conf ;
   
   //
   // In the config you can set allowdebug, but you can also
   // specify the debug attribute in the ~~DIR~~ line...
   //
   if ($conf ["allowdebug"] == 1)
    $this->debug = true ;     
    
   $this->start   = $conf ["start"] ;
   $this->dformat = $conf ["dformat"] ;
   $this->style   = $this->getConf ("style") ;
  }
  
  /**
   * return some info
   */
  function getInfo () {
    return array (
      'author' => 'Jacobus Geluk',
      'email'  => 'Jacobus.Geluk@gmail.com',
      'date'   => '2008-06-28',
      'name'   => 'Dir Plugin',
      'desc'   => 'Shows pages in one or namespaces in a table or list',
      'url'    => 'http://wiki.splitbrain.org/plugin:dir',
    ) ;
  }
 
  /**
   * What kind of syntax are we?
   */
  function getType () {
    return "substition" ;
  }
 
  /**
   * Just before build in links
   */
  function getSort () {
   return 299 ;
  }
 
  /**
   * What about paragraphs?
   */
  function getPType () {
    return "block" ;
  }
 
  /**
   * Register the ~~DIR~~ verb...
   * Supported signatures:
   *
   * 1. ~~DIR~~
   * 2. ~~DIR:...~~
   * 3. ~~DIR?...~~
   */
  function connectTo ($mode) {
    
    $this->Lexer->addSpecialPattern (
      '~~' . DIR_PLUGIN_PATTERN . '~~', $mode, 'plugin_dir'
    ) ;
    $this->Lexer->addSpecialPattern (
      '~~' . DIR_PLUGIN_PATTERN . '[:?][^~]*~~', $mode, 'plugin_dir'
    ) ;
  }
  
  /**
   * Handle the match
   */
  function handle ($match, $state, $pos, &$handler) {
    
    return preg_replace (
      "%~~" . DIR_PLUGIN_PATTERN . ":(=(.*))?~~%", "\\2",
      $match
    ) ;
  }
  
  /**
   * Initialize the current object for each rendering pass
   */
  function _initRender ($mode, &$renderer) {
   
    $rc = FALSE ;
    
    $this->rowNumber   = 0 ;
    $this->opts        = Array () ;
    $this->cols        = Array () ;
    $this->hdrs        = Array () ;
    $this->pages       = Array () ;
    $this->hasTags     = false ;
    $this->excludeTags = Array () ;
    $this->includeTags = Array () ;
    $this->rdr         =& $renderer ;
    $this->rdrMode     = $mode ;
    
    switch ($mode) {
    case 'latex':
      $this->modeIsXHTML = false ;
      $this->modeIsLatex = true ;
      $rc = TRUE ;
      break ;
    case 'xhtml':
      $this->modeIsXHTML = true ;
      $this->modeIsLatex = false ;
      $rc = TRUE ;
      break ;
    default:
      $this->modeIsXHTML = false ;
      $this->modeIsLatex = false ;
    }
    
    return $rc ;   
  }
 
  /**
   * Create output
   */
  function render ($mode, &$renderer, $data) {

    if (! $this->_initRender ($mode, $renderer))
      return false ;
    
    $rc = $this->_dir ($data) ;
    
    if ($this->modeIsLatex)
      $this->processedLatex = true ;

    $this->_showDebugMsg ("Leaving syntax_plugin_dir.render()") ;

    return $rc ;
  }

  /**
  * Put a debug message on screen...
  */
  function _showDebugMsg ($msg) {
  
    if (! $this->debug)
      return ;
      
    if (is_array ($msg)) {
      foreach ($msg as $index => $m) {
        $this->_showDebugMsg ("Array [$index]: " . $m) ;
      }
      return ;
    }
    
    $this->_putNewLine () ;
    
    switch ($this->rdrMode) {
    case 'xhtml':
      $this->_put (DOKU_LF . "<span style=\"color:red;\">~~") ;
      $this->_put (DIR_PLUGIN_PATTERN . "~~: " . $msg . "</span>") ;
      break ;
    case 'latex':
      $this->_put (DOKU_LF . "~~") ;
      $this->_put (DIR_PLUGIN_PATTERN . "~~: " . $msg) ;
      break ;
    }  
  }
 
  /**
   * Load the specified plugin (like the tag or discussion plugin)
   */   
  function _loadPlugin ($plugin) {
     
    if (plugin_isdisabled ($plugin))
      return false ;
      
    $plug = plugin_load ('helper', $plugin) ;
      
    if (! $plug) {
      $this->_showDebugMsg ("Plugin \"$plugin\" NOT loaded!") ;
      return false ;
    }
    
    $this->plugins [$plugin] = $plug ;
    $this->_showDebugMsg ("Plugin \"$plugin\" loaded!") ;
    
    return true ;
  } 
 
  /**
   * Let another plugin generate the content...
   */
  function _pluginCell ($plugin, $id) {
    
    $plug = $this->plugins [$plugin] ;
    
    if (! $plug)
      return 'Plugin $plugin not loaded!' ;
        
    $html = $plug->td ($id) ;
    
    return $html ;
  }

  /**
   * Shows parsed options (in debug mode)
   */   
  function _parseOptionsShow ($data, $dir, $ns) {
    
    if (! $this->debug)
      return ;

    $this->_put (DOKU_LF . "<xmp style=\"font-family: Courier; color: red;\">") ;
    $this->_put (DOKU_LF . "  data = $data") ;
    $this->_put (DOKU_LF . "  dir  = $dir") ;
    $this->_put (DOKU_LF . "  ns   = $ns") ;
    
    foreach ($this->opts as $key => $opt) {
      if (is_array ($opt)) {
        foreach ($opt as $optkey => $optval) {
          $this->_put (DOKU_LF . "  opts[$key][$optkey] = $optval") ;
        }
      } else if (is_bool ($opt)) {
        $this->_put (DOKU_LF . "  opts[$key] = " . ($opt ? "true" : "false")) ;
      } else {
        $this->_put (DOKU_LF . "  opts[$key] = $opt") ;
      }
    }
    $this->_put (DOKU_LF . DOKU_LF . "date: " . date ("D M j G:i:s T Y")) ;
    $this->_put (DOKU_LF . "</xmp>" . DOKU_LF) ;
  }
   
  /**
   * Get the namespace of the parent directory
   * (always prefixed and postfixed with a colon, root is ':')
   */
  function _getParentNS ($id) {
    
    $curNS = getNS ($id) ;
    
    if ($curNS == '')
      return ':' ;

    if (substr ($curNS, 0, 1) != ':') {
      $curNS = ':' . $curNS;
    }
    
    return ':' . $curNS . ':' ;
  }
   
  /**
   * Create a fully qualified namespace from the specified one.
   * The second parameter must be true when the given namespace
   * is never a page id. In that case, the returned namespace
   * always ends with a colon.
   */
  function _parseNS ($ns, $mustBeNSnoPage) {
    
    global $ID ;
    
    if (substr ($ns, 0, 2) == '.:') {
      $ns = ':' . getNS ($ID) . substr ($ns, 1) ;
    } elseif (substr ($ns, 0, 3) == '..:') {
      $ns = $this->_getParentNS ($ID) . substr ($ns, 3) ;
    } elseif ($ns == '..') {
      $ns = $this->_getParentNS ($ID) ;
    } elseif (substr ($ns, 0, 1) == ':') {
    } elseif ($ns == '.' || $ns == '*') {
      $ns = ':' . getNS ($ID) ;
    } else {
      $ns = ':' . getNS ($ID) . ':' . $ns ;
    }
    
    if ($mustBeNSnoPage && substr ($ns, -1) <> ':')
      $ns .= ':' ;
    
    return $ns ;
  }
   
  /**
   * Convert namespace to its path
   */
  function _ns2path ($ns) {
    
    global $conf ;
    
    if ($ns == ':' || $ns == '')
      return $conf ['datadir'] ;
    
    $ns = trim ($ns, ':') ;
    
    $path = $conf ['datadir'] . '/' . str_replace (':', '/', $ns) ;
    
    return $path ;
  }
   
  /**
   * Initialize the opts array...
   */
  function _initOpts ($flags) {
    
    $this->opts = array () ;
    $this->opts ["noheader"] = false ;
    $this->opts ["collapse"] = false ;
    $this->opts ["ego"] = false ;
    
    $flags = split ('\&', $flags) ;
    
    foreach ($flags as $index => $par) {
      $tmp = split ("=", $par) ;
      $key = $tmp [0] ;
      $val = $tmp [1] ;
      switch ($key) {
      case "skip":
      case "cols":
      case "hdrs":
      case "sort":
      case "tag":
        $val = split (';', trim ($val, ';')) ;
        break ;
      case "noheader":
      case "nohead":
      case "nohdr":
        $key = "noheader" ;
        $val = true ;
        break ;
      case "collapse":
        $key = "collapse" ;
        $val = true ;
        break ;
      case "ego":
        $key = "ego" ;
        $val = true ;
        break ;
      case "showheader":
      case "header":
        $key = "noheader" ;
        $val = false ;   
        break ;
      case "nodefaulttitle":
      case "ndt":
        $key = "nodefaulttitle" ;
        $val = true ;
        $this->useDefaultTitle = false ;
        break ;
      case "widedesc":
        $val = true ;
        break ;
      case "table":
        $this->style = "table" ;
        break ;
      case "list":
        $this->style = "list" ;
        break ;
      case "debug":
        $this->debug = true ;
      }
      $this->opts [$key] = $val;
    }
  }   

  /**
   * Check the supplied column names
   */   
  function _parseColumnNames () {
  
    if (is_array ($this->opts ["cols"])) {
      $this->cols = $this->opts ["cols"] ;
    } else {
      $this->cols = Array ("page") ;
    }
  
    if (count ($this->cols) == 0) {
      $cols [] = "page" ;
      $cols [] = "desc" ;
    }
  
    $newCols = Array () ;
  
    foreach ($this->cols as $index => $col) {
      switch ($col) {
      case "page":
      case "desc":
      case "user":
      case "userid":
      case "mdate":
      case "cdate":
      case "rowno":
        break ;
      case "comments":
        $this->_loadPlugin ("discussion") ;
        break ;
      case "tags":
        $this->_loadPlugin ("tag") ;
        break ;
      case "date":
        $col = "mdate" ;
        break ;
      case "description":
        $col = "desc" ;
        break ;
      default:
        $this->_showDebugMsg ("Unrecognized column name: \"$col\"") ;
        $col = '' ;
      }
      if ($col != '') {
        $this->_showDebugMsg ("Recognized column name: $col") ;
        $newCols [] = $col ;
      }
    }
    $this->cols = $newCols ;
    if (count ($this->opts ["hdrs"]) != count ($this->cols)) {
      $this->_showDebugMsg (
        "The number of specified headers (" . count ($this->opts ["hdrs"]) . 
        ") is not equal to the number of specified columns (" .
        count ($this->cols) . ")!"
      ) ;
    }
  }
  
  /**
   * Check the supplied tags
   */   
  function _parseTags () {
   
    $this->hasTags = false ;

    if (is_array ($this->opts ["tag"])) {
      foreach ($this->opts ["tag"] as $tag) {
        if ($tag == NULL || $tag == '')
          continue ;
        $tag = mb_convert_case ($tag, MB_CASE_LOWER, "UTF-8") ;
        if (substr ($tag, 0, 1) == '!') {
          $this->excludeTags [] = substr ($tag, 1) ;
        } else {
          $this->includeTags [] = $tag ;
        }
        $this->hasTags = true ;
      }
      foreach ($this->excludeTags as $tag) {
        $this->_showDebugMsg ("Specified exclude tag: $tag") ;
      }
      foreach ($this->includeTags as $tag) {
        $this->_showDebugMsg ("Specified include tag: $tag") ;
      }
    }
  } 

  /**
   * Check the supplied sort keys
   */   
  function _parseSortKeys () {

    if (is_array ($this->opts ["sort"])) {
     $this->sortKeys = $this->opts ["sort"] ;
    }
    
    $sortKeys = Array () ;
    
    foreach ($this->sortKeys as $index => $sortKey) {
    
      $array = split ('-', strtolower ($sortKey)) ;
      if (count ($array) == 1) {
        $array = Array ($sortKey, "a") ;
      }

      switch ($array [1]) {
      case NULL:
      case "a":
      case "asc":
      case "ascending":
        $array [1] = false ;
        break ;
      case "d":
      case "desc":
      case "descending":
        $array [1] = true ;
        break ;
      default:
        $this->_showDebugMsg (
          "Unrecognized sort column name modifier: " . 
          $array [1]
        ) ;
        $array [1] = false ;
      }
    
      switch ($array [0]) {
      case "page":
      case "desc":
      case "user":
      case "userid":
      case "mdate":
      case "cdate":
      case "rowno":
        break ;
      case "comments":
        $this->_loadPlugin ("discussion") ;
        break ;
      case "tags":
        $this->_loadPlugin ("tag") ;
        break ;
      case "date":
        $array [0] = "mdate" ;
        break ;
      case "description":
        $array [0] = "desc" ;
        break ;
      default:
        $this->_showDebugMsg (
          "Unrecognized sort column name: " . $array [0]
        ) ;
        $array [0] = NULL ;
      }
      if ($array [0]) {
        $this->_showDebugMsg (
          "Sort column " . $array [0] . " " . 
          ($array [1] ? "descending" : "ascending")
        ) ;
        $sortKeys [] = $array ;
      }
    }
    
    $this->sortKeys       = $sortKeys ;  
    $this->nbrOfSortKeys  = count ($this->sortKeys) ;
  }
   
  /**
   * Add a page to the collection of $pages. Check first if it should
   * not be skipped...
   */
  function _addFoundPage (&$data, $ns, $id, $type, $level) {
    
    global $ID ;
    
    $fqid = $ns . $id ; // Fully qualified id...

    //
    // If this file or directory should be skipped, do so
    // 
    switch ($type) {
    case "f":
      if (($fqid == ':' . $ID) && ! $this->opts ["ego"]) // If we found ourself, skip it
        return false ;
      $pageName = noNS ($id) ;
      if ($pageName == $this->start)
        return false ;
      if ($this->opts['skipallfqid']) return false;
      foreach ($this->opts ["skipfqid"] as $index => $skipitem) {
        if ($skipitem) {
          if ($skipitem == $fqid) {
            //
            // Remove the skip rule, it has no use any more...
            //
            $this->opts ["skipfqid"] [$index] = NULL ; 
            $this->_showDebugMsg ("Skipping $fqid due to skip rule $skipitem") ;
            return false ;
          }
        }
      }
      if ( $this->opts ["collapse"] ) {
        // With collapse, only show:
        // - pages within the same namespace as the current page
        if ( $this->_getParentNS($fqid) != $this->_getParentNS($ID) ) {
          return false ;
        }
      }
      $linkid = $fqid ;
      break ;
    case "d":
      $fqid .= ':' ;
      if ($this->opts['skipallns']) return false;
      foreach ($this->opts ["skipns"] as $skipitem) {
        if ($skipitem == $fqid) {
          $this->_showDebugMsg ("Skipping $fqid due to skip rule $skipitem") ;
          return false ;
        }
      }
      if ( $this->opts ["collapse"] ) {
        // With collapse, only show:
        // - sibling namespaces of the current namespace and it's ancestors
        $curPathSplit = split (":", trim (getNS($ID), ":")) ;
        $fqidPathSplit = split (":", trim (getNS($fqid), ":")) ;

        // Find the last parent namespace that matches
        // If there is only one more child namespace in the namespace under evaluation,
        // Then this is a sibling of one of the parent namespaces of the current page.
        // Siblings are ok, grandchild namespaces and below should be skipped (for collapse).
        $clevel = 0 ;
        if (count ($curPathSplit) > 0) {
          while (($clevel < count($fqidPathSplit) - 1) && ($clevel < count($curPathSplit))) {
            if ($curPathSplit[$clevel] == $fqidPathSplit[$clevel]) {
              $clevel++ ;
            } else {
              break ;
            }
          }
        }
        if (count($fqidPathSplit) > $clevel + 1) {
          return false;
        }
      }

      $linkid = $fqid . $this->start ;

      // Don't add startpages the user isn't authorized to read
      if (auth_quickaclcheck (substr($linkid,1)) < AUTH_READ)
        return false ;

      break ;
    }

//  $this->_showDebugMsg ("$level $type $ns$id:") ;
   
    $data [] = array (
      'id'         => $fqid,
      'type'       => $type,
      'level'      => $level,
      'linkid'     => $linkid,
      'timestamp'  => NULL
    ) ;
    
    return true ;
  }   
   
  /**
   * Callback method for the search function in _parseOptions
   */
  function _searchDir (&$data, $base, $file, $type, $level, $opts) {
    
    global $ID ;
    
    $ns = $opts ["ns"] ;
  
    switch ($type) {
    case "d":  
      return $this->_addFoundPage ($data, $ns, pathID ($file), $type, $level) ;
    case "f":
      if (! preg_match ('#\.txt$#', $file))
        return false ;
      //check ACL
      $id = pathID ($file) ;
      if (auth_quickaclcheck ($id) < AUTH_READ)
        return false ;
      $this->_addFoundPage ($data, $ns, $id, $type, $level) ;
    }
  
    return false ;
  }
   
  /**
   * Parse the options after the ~~DIR: string and
   * return true if the table can be generated...
   *
   * A namespace specifaction should start with a colon and the flags
   * should start with a question mark, like this:
   *
   * ~~DIR[[:<namespace>][?<flags>]]~~
   *
   * To not break pages created with an older version of this plugin, this
   * syntax is also supported:
   *
   * ~~DIR:<flags>~~
   *
   * This assumes that no other colon is put in <flags>
   */
  function _parseOptions ($data) {
    
    global $conf ;
    global $ID ;
    
    $ns    = '.' ; 
    $flags = trim ($data, '~') ;
    $flags = substr ($flags, strlen (DIR_PLUGIN_PATTERN)) ;
    $flags = trim ($flags) ;
    
    $this->_showDebugMsg ("specified arguments=" . $flags) ;
    
    if (
      substr ($flags, 0, 1) == ':' &&
      strpos (substr ($flags, 1), '?') === FALSE &&
      strpos (substr ($flags, 1), ':') === FALSE
    ) {
      //
      // This is the "old" syntax where flags do not start with a question mark
      //
      $this->_showDebugMsg ("parseOptions A") ;
      $flags = substr ($flags, 1) ;
    } else if (
      substr ($flags, 0, 1) == ':' &&
      strpos (substr ($flags, 1), '?') === FALSE
    ) {
      //
      // There is no questionmark so it's all namespace specification
      //
      $this->_showDebugMsg ("parseOptions B") ;
      $ns     = substr ($flags, 1) ;
      $flags  = '' ;   
    } else if (substr ($flags, 0, 1) == '?') {
      $this->_showDebugMsg ("parseOptions C") ;
      $flags = substr ($flags, 1) ;
    } else if (strlen ($flags) == 0) {
      $this->_showDebugMsg ("parseOptions D") ;
    } else if (
      strpos (substr ($flags, 1), '?') !== FALSE
    ) {
      $this->_showDebugMsg ("parseOptions E") ;
      $tmp = split ('\?', $flags) ;
  
      if (count ($tmp) == 2) {
        $ns    = substr ($tmp [0], 1) ;
        $flags = $tmp [1] ;
      } else {
        $this->_showDebugMsg ("ERROR: Multiple questionmarks are not supported") ;
        $flags = '' ;
      }
    } else {
      $this->_showDebugMsg ("parseOptions E") ;
      $ns    = $flags ;
      $flags = '' ;
    }
   
    $this->_showDebugMsg ("specified namespace=$ns") ;
    $this->_showDebugMsg ("specified flags=$flags") ;
   
    $ns = $this->_parseNS ($ns, true) ;

    $path = $this->_ns2path ($ns) ;
    $this->_showDebugMsg ("path=$path") ;

    $this->_initOpts ($flags) ;
    $this->_parseColumnNames () ;
    $this->_parseSortKeys () ;
    $this->_parseTags () ;
  
    //
    // Check the column headers
    //
    $this->hdrs = $this->cols ;
    if (is_array ($this->opts ["hdrs"])) {
      foreach ($this->opts ["hdrs"] as $index => $hdr) {
        $this->hdrs [$index] = $hdr ;
      }
    }

    //
    // Check the skip items
    //
    $this->opts ["skipfqid"] = Array () ;
    $this->opts ["skipns"]   = Array () ;
    $this->opts ["skipallfqid"] = false;
    $this->opts ["skipallns"] = false;
    if (is_array ($this->opts ["skip"])) {
      foreach ($this->opts ["skip"] as $skipitem) {
        if ($skipitem == '*:') {
          $this->opts['skipallns'] = true;
        } elseif ($skipitem == '*') {
          $this->opts['skipallfqid'] = true;
        } else {
          $item = $this->_parseNS ($skipitem, false) ;
          if (substr ($item, -1) == ":") {
            $this->opts ["skipns"] [] = $item ;
          } else {
            $this->opts ["skipfqid"] [] = $item ;
          }
        }
      }
    }
  
    $this->_parseOptionsShow ($data, $path, $ns) ;
  
    //
    // Search the directory $dir, only if the pages array
    // is empty, since we can pass here several times (xhtml, latex).
    //
    $this->_showDebugMsg ("Search directory $path") ;
    $this->_showDebugMsg ("for namespace $ns") ;
    
    if (count ($this->pages) == 0) {
      search (
      $this->pages,                // results
      $path,                       // folder root
      array ($this, '_searchDir'), // handler
      array ('ns' => $ns)          // namespace
      ) ;
    }  
    $count = count ($this->pages) ;
    
    $this->_showDebugMsg ("Found " . $count . " pages!") ;
    
    if ($count == 0) {
      $this->_put (DOKU_LF . "\t<p>There are no documents to show.</p>" . DOKU_LF) ;
      return false ;
    }
    
    $this->_sortResult () ;
    
    return true ;
  }
  
  /**
   * Sort the found pages according to the settings
   */   
  function _sortResult () {

    if ($this->nbrOfSortKeys == 0)
      return ;

    usort ($this->pages, array ($this, "_sortPage")) ;     
  }
  
  /**
   * Compare function for usort
   */
  function _sortPage ($a, $b) {

    return $this->_sortPageByKey ($a, $b, 0) ;    
  }
  
  function _sortPageByKey (&$a, &$b, $index) {
    
    if ($index >= $this->nbrOfSortKeys)
      return 0 ;
    
    $keyType  = $this->sortKeys [$index] ;
    $sortKeyA = $this->_getSortKey ($a, $keyType [0]) ;
    $sortKeyB = $this->_getSortKey ($b, $keyType [0]) ;
    
    if ($sortKeyA == $sortKeyB)
      return $this->_sortPageByKey ($a, $b, $index + 1) ;
      
    if ($keyType [1]) {
      $tmp = $sortKeyA ;
      $sortKeyA = $sortKeyB ;
      $sortKeyB = $tmp ;
    }
      
    return ($sortKeyA < $sortKeyB) ? -1 : 1 ;    
  }
  
  /**
   * Produces a sortable key
   */
  function _getSortKey (&$page, $keyType) {
    
    switch ($keyType) {
    case "page":
      return html_wikilink ($page ["id"]) ;
    case "desc":
    case "widedesc":
      return $this->_getMeta ($page, "description", "abstract") ;
    case "mdate":
      return $this->_getMeta ($page, "date", "modified") ;
    case "cdate":
      return $this->_getMeta ($page, "date", "created") ;
    case "user":
      $users = $this->_getMeta ($page, "contributor") ;
      if (is_array ($users)) {
        $index = 0 ;
        foreach ($users as $userid => $user) {
          if ($user && $user <> "") {
            return $user ;
          }
        }
      }
      return $users ;
    case "userid":
      $users = $this->_getMeta ($page, "contributor") ;
      if (is_array ($users)) {
        $index = 0 ;
        foreach ($users as $userid => $user) {
          if ($userid && $userid <> "") {
            return $userid ;
          }
        }
      }
      return $users ;
    case "comments":
      return $this->_pluginCell ("discussion", $page ["linkid"]) ;
    case "tags":
      return $this->_pluginCell ("tag", $page ["linkid"]) ;
    case "rowno":
      return '0' ;
    }
    
    return NULL ;
  }
  
  /**
   * Generate the content for the cell with the page link...
   */
  function _tableCellContentID (&$page) {

    $fqid        = $page ["id"] ;
    $tmplvl      = $page ["level"] - 1 ;
    $spacerWidth = $tmplvl * 20 ;
    $pageid      = $fqid ;
    $name        = NULL ;

    if ($page ["type"] == 'd')
      $pageid .= ':' . $this->start ;
   
    if (! $this->useDefaultTitle) {
      $name = split (':', $fqid) ;
      $name = ucfirst ($name [count ($name) - 1]) ;
    }
  
    switch ($this->rdrMode) {
    case 'latex':
      $this->rdr->internallink ($pageid, $name) ;
      break ;
    case 'xhtml':
      if ($spacerWidth > 0) {
        $this->_put ('<div style="margin-left: ' . $spacerWidth . 'px;">') ;
      }
      $this->_put (html_wikilink ($pageid, $name)) ;
      if ($spacerWidth > 0) {
        $this->_put ('</div>') ;
      }
      break ;
    }
  }
   
  /**
   * Get default value for an unset element
   */
  function _getMeta (&$page, $key1, $key2 = NULL) {
  
    if (! isset ($page ["meta"]))
      $page ["meta"] = p_get_metadata ($page ["linkid"], false, true) ;

    //
    // Use "created" instead of "modified" if null
    //
    if (
      $key1 == "date" && 
      $key2 == "modified" &&
      ! isset ($page ["meta"]["date"]["modified"])
    ) {
      $key2 = "created" ;
    }
    //
    // Return "creator" if "contributor" is null
    //
    if (
      $key1 == "contributor" &&
      ! isset ($page ["meta"]["contributor"])
    ) {
      $key1 = "creator" ;
    }
   
    if (is_string ($key2))
      return $page ["meta"] [$key1] [$key2] ;
      
    return $page ["meta"] [$key1] ;
  }

  /**
   * Generate the table cell content...
   */
  function _tableCellContent (&$page, $col) {

    switch ($col) {
    case "page":
      $this->_tableCellContentID ($page) ;
      break ;
    case "desc":
    case "widedesc":
      $this->_put ($this->_getMeta ($page, "description", "abstract")) ;
      break ;
    case "mdate":
      $this->_putDate ($this->_getMeta ($page, "date", "modified")) ;
      break ;     
    case "cdate":
      $this->_putDate ($this->_getMeta ($page, "date", "created")) ;
      break ;
    case "user":
      $users = $this->_getMeta ($page, "contributor") ;
      if (is_array ($users)) {
        $index = 0 ;
        foreach ($users as $userid => $user) {
          if ($user && $user <> '') {
            if ($index++ > 0) {
              $this->_putNewLine () ;
            }
            $this->_put ($user) ;
          }
        }
      }
      break ;
    case "userid":
      $users = $this->_getMeta ($page, "contributor") ;
      if (is_array ($users)) {
        $index = 0 ;
        foreach ($users as $userid => $user) {
          if ($userid && $userid <> '') {
            if ($index++ > 0) {
              $this->_putNewLine () ;
            }
            $this->_put ($userid) ;
          }
        }
      }
      break ;
    case "comments":
      if (! $this->modeIsLatex)
        $this->_put ($this->_pluginCell ("discussion", $page ["linkid"])) ;
      break ;   
    case "tags":
      if (! $this->modeIsLatex)
        $this->_put ($this->_pluginCell ("tag", $page ["linkid"])) ;
      break ;  
    case "rowno":
      $this->_put ($this->rowNumber) ;
      break ; 
    default:
      $this->_put ($col) ;
    }
  }
    
  /**
   * Rewrite of renderer->table_open () because of class
   */ 
  function _tableOpen () {
  
    if ($this->modeIsLatex) {
      $rdr = $this->rdr ;
      $rdr->_current_tab_cols = 0 ;
      if ($rdr->info ['usetablefigure'] == "on") {
        $this->_putCmdNl ("begin{figure}[h]") ;
      } else {
        $this->_putCmdNl ("vspace{0.8em}") ;
      }
      $rdr->putcmd ("begin{tabular}") ;
      $rdr->put ("{") ;
      foreach ($this->hdrs as $index => $hdr) {
        $rdr->put ("l") ;
        if ($index + 1 < sizeof ($this->hdrs))
          $rdr->put ('|') ;
      }
      $rdr->putnl ("}") ;
      return ;
    }

    switch ($this->style) {
    case "table":
      $class = "inline" ;
      break ;
    case "list":
      $class = "ul" ;
      break;
    default:
      $class = "pagelist" ;
    }
    $this->_showDebugMsg ("Style=" . $this->style . " table class=$class") ;
    $this->_put (DOKU_LF . '<table class="' . $class . '">' . DOKU_LF) ;
 }

  /**
   * Rewrite of renderer->table_close ()
   */
  function _tableClose () {
  
    if ($this->modeIsLatex) {
      $this->rdr->tabular_close () ;
      return ;
    }
      
    $this->rdr->table_close () ;
  }
  
  /**
   * Rewrite of renderer->tableheader_open () because of class
   */ 
  function _tableHeaderCellOpen ($class) {

    if ($this->modeIsLatex)
      return ;

    $this->_put (DOKU_LF . DOKU_TAB . DOKU_TAB . '<th class="' . $class . '">') ;
  }

  /**
   * Rewrite of renderer->tableheader_close ()
   */ 
  function _tableHeaderCellClose ($index) {
  
    if ($this->modeIsLatex) {
      if (($index + 1) == sizeof ($this->hdrs)) {
        $this->rdr->putnl ('\\\\') ;
      } else {
        $this->rdr->put ('&') ;
      }
      return ;
    }
   
    return $this->rdr->tableheader_close () ;
  }

  /**
   * Rewrite of renderer->tablecell_open () because of class
   */ 
  function _tableCellOpen ($colspan, $class) {
  
    if ($this->modeIsLatex)
      return ;
  
    $this->_put (DOKU_LF . DOKU_TAB . DOKU_TAB . '<td class="' . $class . '"') ;
  
    if ($colspan > 1)
      $this->_put (' colspan="' . $colspan . '"') ;
    
    $this->_put (">") ;
  }

  /**
   * Rewrite of renderer->tablecell_close () because of class
   */ 
  function _tableCellClose ($index) {
  
    if ($this->modeIsLatex) {
      if (($index + 1) == sizeof ($this->hdrs)) {
        $this->rdr->putnl ('\\\\') ;
      } else {
        $this->rdr->put ('&') ;
      }
      return ;
    }
      
    return $this->rdr->tablecell_close () ;
  }
 
  /**
   * Return the class name to be used for the <td> showing $col.
   */
  function _getCellClassForCol ($col) {
  
    switch ($col) {
    case "page":
      return "dpage" ;
    case "date":
    case "user":
    case "desc":
    case "comments":
    case "tags":
    case "rowno":
      return $col ;
    case "mdate":
    case "cdate":
      return "date" ;
    case "userid":
      return "user" ;
    case "":
      return "" ;
    }
    $this->_showDebugMsg ("Unknown style class for col $col") ;
    return "desc" ;
  }

  function _tableHeaderRowOpen () {
  
    if ($this->modeIsLatex) {
      $this->_putCmdNl ('hline') ;
      return ;
    }
      
    $this->rdr->tablerow_open () ;
  }

  function _tableHeaderRowClose () {
  
    if ($this->modeIsLatex) {
      $this->_putCmdNl ('hline') ;
      return ;
    }
      
    $this->rdr->tablerow_close () ;
  }
 
  function _tableRowOpen () {
  
    if ($this->modeIsLatex)
      return ;
      
    $this->rdr->tablerow_open () ;
  }

  function _tableRowClose () {
  
    if ($this->modeIsLatex)
      return ;
      
    $this->rdr->tablerow_close () ;
  }
 
  /**
   * Return true if the tag plugin is not loaded,
   * if the ~~DIR~~ line has no tag attribute or
   * if the given page has one of the specified tags.
   */
  function _hasTag ($page) {
  
    if (! $this->hasTags)
      return true ;
  
    $plug = $this->plugins ['tag'] ;
    
    if (! $plug)
      return true ;
  
    //
    // Get the tags of the current page
    //
    $tmp = $this->_getMeta ($page, "subject") ;
    
    if (! is_array ($tmp))
      return false ;
    
    $tags = Array () ;
    
    //
    // Convert them to lowercase
    //
    foreach ($tmp as $tag) {
      $tags [] = mb_convert_case ($tag, MB_CASE_LOWER, "UTF-8") ;
    }
    
    #
    # If there is an intersection with the exclude tags then we can not show
    # the current document
    #
    if (count ($this->excludeTags) > 0) {  
      if (count (array_intersect ($tags, $this->excludeTags)) > 0) {
        $this->_showDebugMsg ('skip') ;
        return false ;
      }
    }      
    #
    # If the intersection with the include tags is not equal (in size) to the
    # array of include tags, we must skip the current document.
    #
    if (count ($this->includeTags) > 0) {
      $intersection = array_intersect ($tags, $this->includeTags) ;
      if (count ($intersection) != count ($this->includeTags)) {
        return false ;
      }
    }
    
    return true ;      
  }
  
  /**
   * Generate the actual table content...
   */
  function _tableContent () {

    $doWideDesc = $this->opts ["widedesc"] ;
      
    if (! $this->opts ["noheader"]) {
      $this->_tableHeaderRowOpen () ;
      foreach ($this->hdrs as $index => $hdr) {
        $this->_tableHeaderCellOpen (
          $this->_getCellClassForCol ($this->cols [$index])
        ) ;
        $this->_put ($hdr) ;
        $this->_tableHeaderCellClose ($index) ;
      }
      $this->_tableHeaderRowClose () ;    
    }
  
    foreach ($this->pages as $page) {
    
      if (! $this->_hasTag ($page))
        continue ;
      
      $this->rowNumber += 1 ;
      
      $this->_tableRowOpen () ;
      foreach ($this->cols as $index => $col) {
        $this->_tableCellOpen (1, $this->_getCellClassForCol ($col)) ;
        $this->_tableCellContent ($page, $col) ;
        $this->_tableCellClose ($index) ;
      }
      $this->_tableRowClose () ;    
      if ($doWideDesc) {
        $this->_tableRowOpen () ;
        $this->_tableCellOpen (count ($this->cols), "desc") ;
        $this->_tableCellContent ($page, "widedesc") ;
        $this->_tableCellClose (0) ;
        $this->_tableRowClose () ;    
      }
    }
  }  
 
  /**
   * Write data to the output stream
   */
  function _put ($data) {
  
    if ($data == NULL || $data == '')
      return ;
    
    switch ($this->rdrMode) {
    case 'xhtml':
      $this->rdr->doc .= $data ;
      break ;
    case 'latex':
      $this->rdr->put ($data) ;
      break ;
    }
  }
 
  /**
   * Write a date to the output stream
   */
  function _putDate ($date) {
  	
    $this->_put (strftime ($this->dformat, $date)) ;
  }
  
  function _putCmdNl ($cmd) {
  
    $this->rdr->putcmdnl ($cmd) ;
  } 
 
  function _putNewLine () {
  
    if ($this->modeIsLatex) {
      $this->_putCmdNl ('newline') ;
    } else {
      $this->_put ('<br />') ;
    }
  }  
 
  /**
   * Do the real work
   */
  function _dir ($data) {

    if (! $this->_parseOptions ($data))
      return false ;
   
    //
    // If we already did the latex pass, skip the xhtml pass
    //
    if ($this->processedLatex && $this->rdrMode == 'xhtml') {
      //return false ;
    }
    
    //
    // Generate the actual table...
    //
    $this->_tableOpen () ;
    $this->_tableContent () ;
    $this->_tableClose () ;
    
    return true ;
  }
  
} // syntax_plugin_dir

//Setup VIM: ex: et ts=2 enc=utf-8 :