source: trunk/gsdl/src/recpt/browsetools.cpp@ 357

/**********************************************************************
 *
 * browsetools.cpp -- 
 * Copyright (C) 1999  The New Zealand Digital Library Project
 *
 * PUT COPYRIGHT NOTICE HERE
 *
 * $Id: browsetools.cpp 344 1999-07-07 05:44:25Z sjboddie $
 *
 *********************************************************************/

/*
   $Log$
   Revision 1.13  1999/07/07 05:44:25  sjboddie
   Made some changes to allow for new way classifiers work (i.e. you can
   now have classifiers containing other classifiers). At present there's
   only a special case for dealing with the hdl 'magazine' section. A bit
   of a redesign is needed to get it completely flexible

   Revision 1.12  1999/07/01 03:47:49  rjmcnab
   Fixed a small warning.

   Revision 1.11  1999/06/27 21:49:01  sjboddie
   fixed a couple of version conflicts - tidied up some small things

   Revision 1.10  1999/06/26 01:07:21  rjmcnab
   Fixed a small "bug" -- well I probably just covered another one...

   Revision 1.9  1999/06/24 05:12:15  sjboddie
   lots of small changes

   Revision 1.8  1999/06/17 03:06:53  sjboddie
   got detach button working properly - the close book icon is now disabled
   when page is detached as the javascript close() function I was using is
   too unreliable over different browsers
   note that in my last comment I meant the "cl" arg (not the "c" arg).

   Revision 1.7  1999/06/16 23:53:14  sjboddie
   tidied a few things up. documentaction::define_external_macros now
   resets the "c" arg if it's set to something stupid by the .xx suffixes

   Revision 1.6  1999/06/16 04:03:47  sjboddie
   Now sets "cl" arg to "search" when going to a document from a search
   results page. This allows the close book icon (in hierarchy toc) to
   take you back to the results page if that's where you came from.
   If you got to the document page somehow other than from a
   classification or a search (i.e. if "cl" isn't set) then the close
   book icon is disabled

   Revision 1.5  1999/06/16 03:11:25  sjboddie
   get_info() now takes a getParents argument

   Revision 1.4  1999/05/10 03:40:26  sjboddie
   lots of changes - slowly getting document action sorted out

   Revision 1.3  1999/04/30 01:59:39  sjboddie
   lots of stuff - getting documentaction working (documentaction replaces
   old browseaction)

   Revision 1.2  1999/03/29 02:14:29  sjboddie

   More changes to browseaction

   Revision 1.1  1999/03/25 03:10:15  sjboddie

   new library for browse stuff

 */


#include "browsetools.h"
#include "OIDtools.h"


// Note that at present the build software is capable (if you write a plugin to do
// it) of generating classifications that contain other classifications of a 
// different type. This module can only handle one case of that however (i.e. an
// AZList containing a Hierarchy classification as used by hdl's 'magazine'
// section). It really needs redesigning to handle all cases.


/*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
Functions for generating a "Book" type table of contents. These should only be called
for document level tocs (i.e. when the "d" argument is set) as I don't think it makes 
sense to display top level classifications in this way.
This type of table of contents is intended for documents whose sub-sections are simply 
numbered as pages.
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/

void book_toc (const text_t &/*classifytitle*/, cgiargsclass &args, 
           recptproto *collectproto, displayclass &disp, 
           outconvertclass &outconvert, ostream &textout, 
           ostream &logout) {

  if (args["d"].empty()) return;

  text_tarray metadata;
  FilterResponse_t response;
  ResultDocInfo_t docinfo;
  text_t booktop, title, author;

  metadata.push_back ("Title");
  metadata.push_back ("hastxt");
  if (get_info (args["d"], args["c"], metadata, false, collectproto, response, logout)) {
     
    docinfo = response.docInfo[0];

    textout 
      << "\n<!-- Table of Contents produced by browsetools::output_book_toc -->\n\n";

    metadata.erase (metadata.begin()+1, metadata.end());
    metadata.push_back ("Creator");
  
    // get title and author of book
    get_top (args["d"], booktop);
    metadata.push_back ("Title");
    metadata.push_back ("Creator");
    get_info (booktop, args["c"], metadata, false, collectproto, response, logout);
    title = response.docInfo[0].metadata[0].values[0];
    author = response.docInfo[0].metadata[1].values[0];
    metadata.erase (metadata.begin(), metadata.end());
  
    textout << outconvert << disp 
        << "<p><center>\n"
        << "<table cellpadding=0 cellspacing=0 width=_pagewidth_>\n"
        << "<tr valign=top><td>\n";

    // don't want arrows and page number if text expanded
    if (!args.getintarg ("gt")) {
    
      // previous arrow
      textout << "<table><tr valign=top>\n";
      textout << outconvert << disp << "<td align=left>_document:prevarrow_</td>\n";
    
      // page ? of ? text
      textout << outconvert << "<td align=center>\n";
      
      if (is_number (docinfo.metadata[0].values[0])) {
    text_t doctop;
    metadata.push_back ("Title");
    get_top (args["d"], doctop);
    // get title of last sibling
    if (get_info (doctop + ".lc", args["c"], metadata, false, collectproto, response, logout)) {
      if (is_number (response.docInfo[0].metadata[0].values[0])) {
        textout << outconvert << disp << "_document:page_" << docinfo.metadata[0].values[0]
            << "_document:of_" << response.docInfo[0].metadata[0].values[0];
      } else {
        textout << outconvert << docinfo.metadata[0].values[0];
      }
    }
      } else {
    textout << outconvert << docinfo.metadata[0].values[0];
      }
  
      // next arrow
      textout << outconvert << disp << "</td>\n<td align=right>_document:nextarrow_</td>\n</table>\n";
    }


    // goto line
    textout << outconvert << disp << "_document:gotoform_";

    // control buttons
    output_controls (args, collectproto, disp, outconvert, textout, logout);
    textout << "</td>\n";

    // title and author
    textout << outconvert << "\n<td valign=top align=right>\n<h2>" << title << "</h2>\n";
    
    if (!author.empty())
      textout << outconvert << "<h4><i>" << author << "</i></h4>\n";

    textout << "</td></tr></table></center>\n";
    textout << "\n<!-- end of Table of Contents -->\n";


  }
}


/*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
Functions for generating a "Hierarchy" type table of contents. These can be used either
at top classification level or at document level (the difference being that a cover
image and control buttons are displayed at document level).
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/

void hierarchy_toc (const text_t &classifytype, const text_t &/*classifytitle*/, 
            cgiargsclass &args, recptproto *collectproto, 
            displayclass &disp, outconvertclass &outconvert, 
            ostream &textout, ostream &logout) {

  textout << "\n<!-- Table of Contents produced by browsetools::hierarchy_toc -->\n\n";
  textout << "<p><table width=100% cellpadding=0 cellspacing=0 border=0><tr>\n";

  // get the cover image (if there is one) and the control buttons
  if (!args["d"].empty()) {
    textout << "<td valign=top width=200>\n";
    output_cover_image (args, collectproto, disp, outconvert, textout, logout);
    output_controls (args, collectproto, disp, outconvert, textout, logout);
    textout << "</td>\n";
  }
  
  // get table of contents
  textout << "<td valign=top>\n"
      << "<table>\n";

  output_hierarchy (classifytype, args, collectproto, disp, outconvert, textout, logout);
  
  textout << "</table>\n"
      << "</td></tr></table>\n"
      << "\n<!-- end of Table of Contents -->\n";
}

void output_hierarchy (const text_t &classifytype, cgiargsclass &args, 
               recptproto *collectproto, displayclass &disp, 
               outconvertclass &outconvert, ostream &textout, 
               ostream &logout) {

  if (args.getintarg("gc"))
    output_expanded_hierarchy_toc(args, collectproto, disp, outconvert, textout, logout);
  else
    output_contracted_hierarchy_toc(classifytype, args, collectproto, disp, outconvert, textout, logout);
}

// at the moment this just writes out the html to display 
// the cover image (assuming it's called cover.jpg)
// this whole thing should be done with a call to the collection
// server which would send a link to the cover image if there
// was one otherwise send title, author and stuff
void output_cover_image (cgiargsclass &args, recptproto */*collectproto*/, 
             displayclass &disp, outconvertclass &outconvert, 
             ostream &textout, ostream &/*logout*/) {

  if (args["d"].empty()) return;

  textout << outconvert << disp << 
    "<img src=\"_httpcollection_/archives/_thisOID_/cover.jpg\"><br>\n";
}

// output_controls displays the detach, expand/contract contents,
// expand/contract text and highlighting/no highlighting buttons
// and the warning if expanded text is going to be large
void output_controls (cgiargsclass &args, recptproto *collectproto, 
              displayclass &disp, outconvertclass &outconvert, 
              ostream &textout, ostream &logout) {

  if (args["u"] != "1") {
  
    FilterResponse_t response;
    text_tarray metadata;
    text_t top;
    get_top (args["d"], top);

    text_tarray buttons;
    
    // detach button
    buttons.push_back ("_document:imagedetach_");

    // highlighting button
    if (args["hl"] == "1") 
      buttons.push_back ("_document:imagenohighlight_");
    else 
      buttons.push_back ("_document:imagehighlight_");

    // expand/contract contents button - only have this if it's
    // a Hierarchy type toc
    metadata.push_back ("classifytype");
    if (get_info (top, args["c"], metadata, false, collectproto, response, logout)) {
      if (response.docInfo[0].metadata[0].values[0] == "Hierarchy") 
    if (args["gc"] == "1")
      buttons.push_back ("_document:imagecontracttoc_");
    else 
      buttons.push_back ("_document:imageexpandtoc_");
    }
    
    // expand/contract text button
    if (args.getintarg("gt"))
      buttons.push_back ("_document:imagecontracttext_");
    else 
      buttons.push_back ("_document:imageexpandtext_");

    text_tarray::const_iterator here = buttons.begin();
    text_tarray::const_iterator end = buttons.end();
    int count = 0;
    while (here != end) {
      if ((count != 0) && ((count % 3) == 0)) textout << "<br>\n";
      textout << outconvert << disp << *here;
      count ++;
      here ++;
    }
  }
}


void output_contracted_hierarchy_toc (const text_t &classifytype, cgiargsclass &args, 
                      recptproto *collectproto,displayclass &disp, 
                      outconvertclass &outconvert, ostream &textout, 
                      ostream &logout) {

  int colnum, tabcount = 0;
  text_tarray parents, metadata;
  FilterResponse_t siblings;
  FilterResponse_t response;

  text_t &arg_d = args["d"];
  text_t &arg_cl = args["cl"];

  metadata.push_back ("doctype");
  metadata.push_back ("Title");
  metadata.push_back ("hastxt");
  metadata.push_back ("haschildren");

  // load up parent and sibling arrays
  if (arg_d.empty()) {
    if (has_children (arg_cl, args["c"], collectproto, logout)) {
      get_parents_array (arg_cl + ".fc", parents);
      if (!get_children (arg_cl, args["c"], metadata, 
             collectproto, siblings, logout))
    return;
    } else {
      get_parents_array (arg_cl, parents);
      if (!get_children (arg_cl + ".pr", args["c"], metadata, 
             collectproto, siblings, logout))
    return;
    }
    // don't want top parent of classification to be displayed
    if (!parents.empty()) parents.erase (parents.begin());

    // this is a special case for an AZList containing a Hierarchy toc
    if (classifytype == "AZList" && !parents.empty())
      parents.erase (parents.begin());

  } else {
    if (has_children (arg_d, args["c"], collectproto, logout)) {
      get_parents_array (arg_d + ".fc", parents);
      if (!get_children (arg_d, args["c"], metadata, 
             collectproto, siblings, logout))
    return;
    } else {
      get_parents_array (arg_d, parents);
      if (!get_children (arg_d + ".pr", args["c"], metadata, 
             collectproto, siblings, logout))
    return;
    }
  }

  colnum = parents.size() + 1;

  // sort out toc of sections parents
  if (!parents.empty()) 
    output_parents_toc(args, parents, tabcount, colnum, disp, collectproto,
               outconvert, textout, logout);
  
  // sort out toc of sections siblings
  if (!siblings.docInfo.empty()) 
    output_siblings_toc (args, siblings, tabcount, colnum, disp,
             outconvert, textout, logout);
}


void output_expanded_hierarchy_toc (cgiargsclass &args, recptproto *collectproto,
                    displayclass &disp, outconvertclass &outconvert,
                    ostream &textout, ostream &logout) {

  text_t OID, topOID, classifytype, icon;
  FilterResponse_t response;
  int tabcols=0, totalcols=0, lasttabcols=0;

  int gt = args.getintarg("gt");
  text_t doclink = "<a href=\"_httpdocument_&cl=";

  text_t &arg_d = args["d"];
  text_t &arg_cl = args["cl"];

  if (arg_d.empty()) {
    if (arg_cl.empty()) return;
    OID = arg_cl;
    topOID = OID; // don't always want to expand from top if expanding classifications
    classifytype = "classify";
  } else {
    OID = arg_d;
    get_top (arg_d, topOID);
    classifytype = "Document";
  }

  // Get OIDs and metadata of all topOIDs contents (and topOID itself)
  get_contents (topOID, classifytype, totalcols, args["c"], collectproto, response, logout);
  int excess = countchar (topOID.begin(), topOID.end(), '.');
  totalcols -= excess;

  // allow for pointer
  if (classifytype == "Document" && !gt) totalcols += 2;
  else totalcols += 1;

  ResultDocInfo_tarray::const_iterator thissection = response.docInfo.begin();
  ResultDocInfo_tarray::const_iterator lastsection = response.docInfo.end();
  
  int count = 1;
  while (thissection != lastsection) {
    
    const text_t &title = (*thissection).metadata[0].values[0];
    const int haschildren = (*thissection).metadata[1].values[0].getint();
    const text_t &doctype = (*thissection).metadata[2].values[0];

    text_t icontabs, tab, pointer;

    // set up icon
    icon = "_document:iconsmalltext_";
    if (is_top((*thissection).OID))
      if (classifytype == "Document") icon = "_document:iconopenbook_";
      else 
    if (doctype == "classify") icon = "_document:iconopenbookshelf_";
    else icon = "_document:iconclosedbook_";
    else if (haschildren) 
      if (classifytype == "Document") icon = "_document:iconopenfolder_";
      else icon = "_document:iconopenbookshelf_";
    
    // set up tabbing
    if ((classifytype == "classify") && (doctype != "classify"))
      tabcols = lasttabcols + 1;
    else {
      tabcols = countchar ((*thissection).OID.begin(), (*thissection).OID.end(), '.');
      lasttabcols = tabcols;
    }
    tabcols -= excess;

    for (int i = 0; i < tabcols; i++) 
      icontabs += "_document:icontab_";
    
    // set up pointer
    if (classifytype == "Document" && !gt) {
      if ((*thissection).OID == OID) pointer = "_document:iconpointer_";
      else pointer = "_document:icontab_";
      tabcols ++;
    }
    
    int colsremaining = totalcols - tabcols;

    if (tabcols > 0) {
      tab = "<td";
      if (tabcols > 1) tab += " colspan=" + text_t(tabcols);
      tab += ">" + icontabs + pointer + "</td>";
    }

    textout << outconvert << disp << "<tr>" << tab << "<td>";
    
    if ((classifytype == "Document") && (is_top((*thissection).OID)) && 
    (args.getintarg("x")))
      textout << outconvert << disp << icon << "</td><td";

    else {
      if (!gt) {
    const text_t &thisOID = (*thissection).OID;
    text_t link;
    if (is_top (thisOID))
      if (classifytype == "classify")
        link = doclink + arg_cl + "&d=" + thisOID + "\">";
      else
        if (arg_cl.empty())
          link.clear();
        else if (arg_cl == "search")
          link = "<a href=\"_httpquery_\">";
        else
          link = doclink + arg_cl + "\">";
    else
      if (haschildren)
        if (classifytype == "classify")
          link = doclink + thisOID + ".pr\">";
        else
          link = doclink + arg_cl + "&d=" + thisOID + ".pr\">";
      else
        if (classifytype == "classify")
          link = doclink + thisOID + "\">";
        else
          link = doclink + arg_cl + "&d=" + thisOID + "\">";
    
    textout << outconvert << disp << link;
      } else {
    textout << "<a href=\"#" << count << "\">";
    count ++;
      }
    
      textout << outconvert << disp << icon << "</a></td><td";
    }
    if (colsremaining > 1) textout << " colspan=" << colsremaining;
    textout << outconvert << disp << ">" << title << "</td></tr>\n";

    thissection ++;
  }
}


void output_parents_toc (cgiargsclass &args, const text_tarray &parents,
             int &tabcount, int &colnum, displayclass &disp,
             recptproto *collectproto, outconvertclass &outconvert,
             ostream &textout, ostream &logout) {  

  text_t tab, icon;
  text_tarray metadata;
  FilterResponse_t response;
  text_t doclink = "<a href=\"_httpdocument_";

  text_t &arg_cl = args["cl"];

  metadata.push_back ("doctype");
  metadata.push_back ("Title");

  text_tarray::const_iterator thisparent = parents.begin();
  text_tarray::const_iterator end = parents.end();

  while (thisparent != end) {
    if (get_info (*thisparent, args["c"], metadata, false, collectproto, response, logout)) {
      text_t &doctype = response.docInfo[0].metadata[0].values[0];
      text_t &title = response.docInfo[0].metadata[1].values[0];

      text_t icontabs, pointer;
      tab.clear();
      
      // set up icon for this parent
      icon = "_document:iconopenfolder_";
      if (doctype == "classify") icon = "_document:iconopenbookshelf_";
      else if (is_top(*thisparent)) icon = "_document:iconopenbook_";

      for (int j = 0; j < tabcount; j++)
    icontabs += "_document:icontab_";

      if (doctype != "classify") {
    if (*thisparent == args["d"]) {
      icontabs += "_document:iconpointer_";
      if (is_top (*thisparent))
        tabcount ++;
      else 
        icontabs.erase (icontabs.begin(), icontabs.begin()+18);
    }
      }
      
      if (!icontabs.empty()) {
    tab = "<td valign=top";
    if (tabcount > 1) tab += " colspan=" + text_t(tabcount);
    tab += ">" + icontabs + "</td>";
      }
      tabcount ++;
      
      textout << outconvert << disp << "<tr>" << tab << "<td valign=top>";

      if (is_top(*thisparent) && args["x"] == "1") {
    textout << outconvert << disp << icon;
      } else {
    text_t link;
    if (doctype == "classify") link = doclink + "&cl=" + *thisparent + ".pr\">";
    else 
      if (is_top (*thisparent)) 
        if (arg_cl.empty())
          link.clear();
        else if (arg_cl == "search")
          link = "<a href=\"_httpquery_\">";
        else
          link = doclink + "&cl=" + arg_cl + "\">";
      else link = doclink + "&cl=" + arg_cl + "&d=" + *thisparent + ".pr\">";

    textout << outconvert << disp << link << icon << "</a>";
      }
      textout << "</td><td"; 
      if (colnum > 1) textout << outconvert << " colspan=" << text_t(colnum);
      textout << outconvert << disp << ">" << title << "</td></tr>\n";
      colnum --;
    }
    thisparent ++;
  }
}

void output_siblings_toc (cgiargsclass &args, const FilterResponse_t &siblings, 
              int &tabcount, int &colnum, displayclass &disp, 
              outconvertclass &outconvert, ostream &textout, 
              ostream &/*logout*/) {

  text_t tab, icon, pointer, child, doclink;
  int count = 1;

  doclink = "<a href=\"_httpdocument_";
  
  ResultDocInfo_tarray::const_iterator thissibling = siblings.docInfo.begin();
  ResultDocInfo_tarray::const_iterator sibend = siblings.docInfo.end();
  
  while (thissibling != sibend) {

    const text_t &doctype = (*thissibling).metadata[0].values[0];
    const text_t &title = (*thissibling).metadata[1].values[0];
    int hastxt = (*thissibling).metadata[2].values[0].getint(); 
    int haschildren = (*thissibling).metadata[3].values[0].getint();
    int gt = args.getintarg("gt");

    // set up icon for this sibling
    icon = "_document:iconclosedfolder_";
    if (doctype == "classify") icon = "_document:iconclosedbookshelf_";
    else if (is_top((*thissibling).OID)) icon = "_document:iconclosedbook_";
    
    // fit pointer into tabbing if current section
    // note that we don't want pointers at classification levels anymore
    // (unless the classification contains text)
    pointer = "_document:icontab_";
    if (doctype == "classify") {
      if ((*thissibling).OID == args["cl"] && hastxt)
    pointer = "_document:iconpointer_";
    } else if ((*thissibling).OID == args["d"]) pointer = "_document:iconpointer_";
    
    text_t thesetabs;
    for (int j = 0; j < (tabcount - 1); j++)
      thesetabs += "_document:icontab_";
    
    tab = "<td valign=top";
    if (tabcount > 1) tab += " colspan=" + text_t(tabcount);
    tab += ">" + thesetabs + pointer + "</td>";
    
    if (!haschildren) {
      // sibling is text document
      icon = "_document:iconsmalltext_";
      text_t link;
      if (doctype == "classify") link = "&cl=" + (*thissibling).OID;
      else link = "&cl=" + args["cl"] + "&d=" + (*thissibling).OID;

      textout << outconvert << disp << "<tr>" << tab << "<td valign=top>";
      if (!gt) {
    textout << outconvert << disp << doclink << link;
      } else {
    textout << "<a href=\"#" << count;
    count ++;
      }
      textout << outconvert << disp << "\">" << icon << "</a></td><td";
      if (colnum > 1) textout << " colspan=" << colnum;
      textout << outconvert << disp << ">" << title << "</td></tr>\n";

    } else {
      // sibling is closed book or folder
      text_t link;
      if (doctype == "classify") link = "&cl=" + (*thissibling).OID;
      else link = "&cl=" + args["cl"] + "&d=" + (*thissibling).OID;

      textout << outconvert << disp << "<tr>" << tab << "<td valign=top>" 
          << doclink << link << "\">" << icon << "</a></td><td";
      if (colnum > 1) textout << " colspan=" << colnum;
      textout << outconvert << disp << ">" << title << "</td></tr>\n";
    }
    thissibling ++;
  }
}


/*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
Functions for generating a "List" type table of contents. These can be used only
at classification level as it doesn't make sense to display document level stuff
this way (I think!!)
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/

void list_toc (const text_t &/*classifytype*/, const text_t &classifytitle, 
           cgiargsclass &args, recptproto *collectproto, 
           displayclass &disp, outconvertclass &outconvert, 
           ostream &textout, ostream &logout) {

  text_tarray metadata;
  FilterResponse_t response;
  text_t &arg_cl = args["cl"];
  text_t doclink = "<a href=\"_httpdocument_&cl=" + arg_cl + "&d=";

  metadata.push_back (classifytitle);
  metadata.push_back ("Title");

  if (get_children (arg_cl, args["c"], metadata, collectproto, response, logout)) {

    textout
      << "\n<!-- Table of Contents produced by browsetools::output_list_toc "
      << "-->\n\n<p>\n";

    ResultDocInfo_tarray::const_iterator sechere = response.docInfo.begin();
    ResultDocInfo_tarray::const_iterator secend = response.docInfo.end();

    while (sechere != secend) {

      const text_t &ctitle = (*sechere).metadata[0].values[0];
      const text_t &title = (*sechere).metadata[1].values[0];

      if (!ctitle.empty()) {
    textout << outconvert << disp << "<br>" << doclink << (*sechere).OID 
        << "\">" + ctitle + "</a>\n"; 
      } else if (!title.empty()) {
    textout << outconvert << disp << "<br>" << doclink << (*sechere).OID 
        << "\">" + title + "</a>\n";
      }
      sechere ++;
    }

    textout << "\n<!-- end of Table of Contents -->\n";
  }
}


/*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
Functions for generating an "AZList" type table of contents. These can be used only
at classification level as it doesn't make sense to display document level stuff
this way (I think!!)
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/

void azlist_toc (const text_t &classifytype, const text_t &classifytitle, 
         cgiargsclass &args, recptproto *collectproto, 
         displayclass &disp, outconvertclass &outconvert, 
         ostream &textout, ostream &logout) {

  text_tarray metadata;
  FilterResponse_t response;
  text_t &arg_cl = args["cl"];

  textout
    << "\n<!-- Table of Contents produced by browsetools::azlist_toc -->\n\n"
    << "<table cellpadding=0 cellspacing=2>\n";


  if (classifytype == "AZList") {

    metadata.push_back ("Title");
    metadata.push_back ("Creator");
    metadata.push_back ("doctype");

    if (get_children (arg_cl, args["c"], metadata, collectproto, response, logout))
      output_azlist (response, classifytitle, arg_cl, disp, outconvert, textout);
  } 

  else if (classifytype == "Hierarchy")
    output_hierarchy ("AZList", args, collectproto, disp, outconvert, textout, logout);

  textout << "</table>\n"
      << "<!-- end of Table of Contents -->\n";

}

// note that this function expects response to contain three fields of metadata
// ("Title", "Creator", "doctype") - if they're not there it may cause a run-time error
void output_azlist (const FilterResponse_t &response, const text_t &classifytitle,
            const text_t &arg_cl, displayclass &disp, 
            outconvertclass &outconvert, ostream &textout) {

  bool iscreator = false;
  if (classifytitle == "Creator") iscreator = true;

  ResultDocInfo_tarray::const_iterator sechere = response.docInfo.begin();
  ResultDocInfo_tarray::const_iterator secend = response.docInfo.end();

  while (sechere != secend) {

    const text_t &title = (*sechere).metadata[0].values[0];
    const text_t &creator = (*sechere).metadata[1].values[0];
    const text_t &doctype = (*sechere).metadata[2].values[0];

    text_t link = "<a href=\"_httpdocument_&cl=";
    text_t icon = "_document:iconclosedbook_";

    if (doctype == "classify") {
      icon = "_document:iconclosedbookshelf_";
      link += (*sechere).OID;
    } else {
      link += arg_cl + "&d=" + (*sechere).OID;
    }

    if (iscreator) {
      if (!creator.empty()) {
    textout << outconvert << disp << "<tr><td valign=top>" << link << "\">"
        << icon << "</a></td><td>" << creator << "</td><td>";
    
    if (!title.empty())
      textout << outconvert << "&nbsp;&nbsp;" << title;
      }
    } else {
      if (!title.empty()) {
    textout << outconvert << disp << "<tr><td valign=top>" << link << "\">"
        << icon << "</a></td><td>" << title << "</td><td>";
    
    if (!creator.empty())
      textout << outconvert << "&nbsp;&nbsp;" << creator;
      }
    }
    textout << "</td></tr>\n";
    sechere ++;
  }
}


/*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
Functions for generating a "DateList" type table of contents. These can be used only
at classification level as it doesn't make sense to display document level stuff
this way (I think!!)
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/

void datelist_toc (const text_t &/*classifytype*/, const text_t &/*classifytitle*/, 
           cgiargsclass &/*args*/, recptproto */*collectproto*/, 
           displayclass &/*disp*/, outconvertclass &/*outconvert*/, 
           ostream &/*textout*/, ostream &/*logout*/) {
}



/*-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-*/

// set_arrow_macros sets the _httpprevarrow_ and _httpnextarrow_ macros
// it shouldn't be called if OID is the top level of a book 
// as the "hasprevious" and "hasnext" metadata won't be set
// when the filter can't get OIDs parent info - one day I'll
// fix this ;-)
void set_arrow_macros (const text_t &OID, const text_t &classifytype,
               displayclass &disp, recptproto *collectproto, 
               const text_t &collection, ostream &logout) {

  if (OID.empty()) return;

  text_tarray metadata;
  FilterResponse_t response;

  metadata.push_back ("haschildren");
  metadata.push_back ("hasnext");
  metadata.push_back ("hasprevious");
  // get "haschildren", "hasnext" and "hasprevious" metadata for OID
  if (get_info (OID, collection, metadata, false, collectproto, response, logout)) {

    text_t haschildren = response.docInfo[0].metadata[0].values[0];
    text_t hasnext = response.docInfo[0].metadata[1].values[0];
    text_t hasprevious = response.docInfo[0].metadata[2].values[0];

    if ((classifytype == "Hierarchy") || (classifytype == "Book")) {
      if (haschildren == "1") 
    disp.setmacro ("httpnextarrow", "document", 
               "_If_(_cgiargd_,_httpdocument_&cl=_cgiargcl_&d=_cgiargd_.fc,_httpdocument_&cl=_cgiargcl_.fc)");
      else if (hasnext == "1")
    disp.setmacro ("httpnextarrow", "document", 
               "_If_(_cgiargd_,_httpdocument_&cl=_cgiargcl_&d=_cgiargd_.ns,_httpdocument_&cl=_cgiargcl_.ns)");
      else {
    // see if parent has younger siblings
    if (get_info (OID + ".pr", collection, metadata, false, collectproto, response, logout)) {
      if (!response.docInfo[0].metadata.empty() &&
          response.docInfo[0].metadata[1].values[0] == "1")
        disp.setmacro ("httpnextarrow", "document", 
               "_If_(_cgiargd_,_httpdocument_&cl=_cgiargcl_&d=_cgiargd_.pr.ns,_httpdocument_&cl=_cgiargcl_.pr.ns)");
    }
      }

      if (hasprevious == "1") {
    // see if OIDs older sibling has children
    if (get_info (OID + ".ps", collection, metadata, false, collectproto, response, logout)) {
      if (!response.docInfo[0].metadata.empty() &&
          response.docInfo[0].metadata[0].values[0] == "1")
        disp.setmacro ("httpprevarrow", "document", 
               "_If_(_cgiargd_,_httpdocument_&cl=_cgiargcl_&d=_cgiargd_.ps.lc,_httpdocument_&cl=_cgiargcl_.ps.lc)");
      else 
        disp.setmacro ("httpprevarrow", "document", 
               "_If_(_cgiargd_,_httpdocument_&cl=_cgiargcl_&d=_cgiargd_.ps,_httpdocument_&cl=_cgiargcl_.ps)");
    } 
      } else if (!is_top (OID))
    disp.setmacro ("httpprevarrow", "document", 
               "_If_(_cgiargd_,_httpdocument_&cl=_cgiargcl_&d=_cgiargd_.pr,_httpdocument_&cl=_cgiargcl_.pr)");
    }

    else {
      if (hasnext == "1")
    disp.setmacro ("httpnextarrow", "document", 
               "_If_(_cgiargd_,_httpdocument_&cl=_cgiargcl_&d=_cgiargd_.ns,_httpdocument_&cl=_cgiargcl_.ns)");
      if (hasprevious == "1")
    disp.setmacro ("httpprevarrow", "document", 
               "_If_(_cgiargd_,_httpdocument_&cl=_cgiargcl_&d=_cgiargd_.ps,_httpdocument_&cl=_cgiargcl_.ps)");
    }
  }
}