Changeset 32 for trunk

Timestamp:

1998-11-25T15:45:00+13:00 (26 years ago)

Author:

sjboddie

Message:

Altered existing collections (gberg, unu, unesco and hdl) to fit in
with new dirctory structure.
Altered browse software - put most of contents of collections browse.cpp
files (e.g. hdlbrowse.cpp) into browse.cpp

Location:

trunk/gsdl

Files:

• setup.bat (deleted)
• src/library/browse.cpp (modified) (1 diff)
• src/library/browse.h (modified) (1 diff)
• src/library/locateinfo.cpp (modified) (2 diffs)

trunk/gsdl/src/library/browse.cpp

@@ -1 +1 @@
 #include "browse.h"
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+// get_browse_bar returns (in return_text) the html for the browse bar at the top of  
+// each page with the button for the current classification hierarchy deactivated 
+
+void browseclass::get_browse_bar(const text_t &targetdoc, text_t &return_text) {
+  if (targetdoc[0] == 'B') return_text = "_imagestandardbar_";
+  else {
+    return_text = "_browse:imagebrowse";
+    return_text.push_back(targetdoc[0]);
+    return_text += "bar_";
+  }
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////////////////
+// toc functions
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+// get_list_toc returns all the titles of the sections in secarray as a list of links
+// (i.e. as used by howto classifications in hdl collection)
+void browseclass::get_list_toc (vector<text_t> &secarray, text_t &collection,
+                gdbmclass &gdbm, text_t &return_text) {
+  gdbm_info info;
+  text_t section, child;
+
+  text_t doclink = "<a href=\"_httptext_&d=";
+  return_text += "<p>\n";
+  
+  vector<text_t>::const_iterator thissection = secarray.begin();
+  vector<text_t>::const_iterator end = secarray.end();
+  
+  while (thissection != end) {
+    
+    section.clear();
+    child.clear();
+    // get info on this section from gdbm
+    if (is_book(*thissection)) get_book(*thissection, section);
+    else section = *thissection;
+
+    gdbm.getinfo(section, collection, info);
+    get_first_section(info.c, child);
+    
+    //    return_text += "<br>" + doclink + *thissection + "." + child + "\">" + info.t + "</a>\n";
+    return_text += "<br>" + doclink + *thissection + "." + child + ".1\">" + info.t + "</a>\n";
+    thissection ++;
+  }
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+// get_page_toc returns links to previous and next pages and text box for going to
+// a selected page (as used by gberg collection). It is intended for use with collections
+// whose documents are simply numbered as pages (should be single level TOCs).
+// There may be introductory text sections before numbered pages.
+void browseclass::get_page_toc (cgiargsclass &args, const text_t &booksection, 
+                const text_t &classification, const text_t &class_string,
+                gdbmclass &gdbm, text_t &return_text) {
+  gdbm_info info, topinfo;
+  text_t previous, next;
+  vector<text_t> contents;
+  
+  // don't want arrows and page number if text expanded
+  if (args["g"][1] != '1') {
+    
+    // get links to previous and next sections.
+    get_prev_next_links(booksection, args["c"], previous, next);
+    
+    return_text += "<p>\n<table cellpadding=\"0\" cellspacing=\"0\">\n";
+    return_text += "<tr valign=\"absmiddle\">\n";
+    
+    // get previous arrow
+    if (gdbm.exists(previous, args["c"])) {
+      return_text += "<td><a href=\"_httptext_&d=" + classification + "." + previous;
+      return_text += "\">_iconless_</a></td>\n";
+    }
+    
+    // get page ? of ? text
+    return_text += "<td align=\"center\">\n";
+    gdbm.getinfo(booksection, args["c"], info);
+    if (is_number(info.t)) {
+      splitstring(class_string, contents);
+      gdbm.getinfo(contents.back(), args["c"], topinfo);
+      if (is_number(topinfo.t))
+    return_text += "&nbsp;page " + info.t + " of " + topinfo.t + "&nbsp;";
+      else 
+    return_text += "&nbsp;" + info.t + "&nbsp;";
+    } else {
+      return_text += " " + info.t + " ";
+    }
+    return_text += "</td>\n";
+
+    // get next arrow
+    if (gdbm.exists(next, args["c"])) {
+      return_text += "<td><a href=\"_httptext_&d=" + classification + "." + next;
+      return_text += "\">_iconmore_</a></td>\n";
+    }
+    return_text += "</tr></table>\n";
+  }
+  // goto line
+  return_text += "_gotoform_";
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+// get_standard_toc is the standard (unexpanded) toc used by hdl, unu, unesco etc.
+
+void browseclass::get_standard_toc(cgiargsclass &args, text_t &booksection, 
+                   const text_t &classification, gdbmclass &gdbm, 
+                   text_t &return_text) {
+  
+  //  text_t doclink, tab, pagetype, section, icon, pointer, fulldoc;
+  int colnum, tabcount = 0;
+  text_t fulldoc;
+  //  gdbm_info info;
+  //  vector<text_t> contents, parents, siblings;
+    vector<text_t> parents, siblings;
+
+  if (!booksection.empty()) fulldoc = classification + "." + booksection;
+  else fulldoc = classification;
+  
+  get_parents (fulldoc, parents);
+  get_siblings (classification, booksection, gdbm, args["c"], siblings);
+  
+  // remove everything above top level of book from parents
+  // list if inside of book 
+  if (!booksection.empty() && !is_top_level(booksection)) {
+    vector<text_t> temp;
+    for (unsigned int i = 0; i < parents.size(); i++) {
+      if (is_book(parents[i])) temp.push_back(parents[i]);
+    }
+    parents = temp;
+  }
+  
+  // remove top level of title and author hierarchies
+  if (((classification[0] == 'T') || (classification[0] == 'A')) && 
+      (booksection.empty() || is_top_level(booksection))) {
+    if (!parents.empty())
+      parents.erase(parents.begin(), parents.begin()+1);
+  }
+  colnum = parents.size() + 1;
+
+  // sort out toc of sections parents
+  if (parents.size() > 0) 
+    get_parents_toc(args, parents, gdbm, tabcount, colnum, return_text);
+  
+  // sort out toc of sections siblings
+  if (siblings.size() > 0) 
+    get_siblings_toc (args, siblings, gdbm, booksection, classification, 
+              tabcount, colnum, return_text);
+
+  return_text += "</table>\n";
+  return_text += "</td></tr></table>\n";
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+// get_expanded_toc is the expanded toc used by hdl, unu, unesco etc.
+
+void browseclass::get_expanded_toc(cgiargsclass &args, text_t &booksection, 
+                   const text_t &classification, gdbmclass &gdbm, 
+                   text_t &return_text) {
+  
+  text_t doclink, icon, pointer, tab, pagetype;
+  int totalcols, tabcols, tabsleft;
+  vector<text_t> contents;
+  gdbm_info info;
+  
+  // get array of all contents to be included (all contents of entire book)
+  text_t book_top;
+  get_book_top (booksection, book_top);
+  get_contents (book_top, gdbm, args["c"], contents, totalcols);
+  
+  vector<text_t>::const_iterator section = contents.begin();
+  vector<text_t>::const_iterator end = contents.end();
+  
+  int count = 1;
+  while (section != end) {
+    tab.clear();
+    gdbm.getinfo(*section, args["c"], info);
+    text_t icontabs;
+
+    // set up icon
+    icon = "_iconsmalltext_";
+    if (is_top_level(*section)) icon = "_iconopenbook_";
+    else if (!info.c.empty()) icon = "_iconopenfolder_";
+
+    // set up pointer
+    if (*section == booksection) pointer = "_iconpointer_";
+    else pointer = "_icontab_";
+
+    // set up tabbing
+    tabcols = count_dots(*section);
+    for (int i = 0; i < (tabcols - 1); i++) {
+      icontabs += "_icontab_";
+    }
+    //char *tabcolsstr;
+    //itoa(tabcols, tabcolsstr, 10);
+    tab = "<td valign=top colspan=" + text_t(tabcols);
+    tab += ">" + icontabs + pointer + "</td>";
+    tabsleft = totalcols - tabcols;
+    
+    // set up url
+    if (is_book(*section) && !is_top_level(*section))   
+      doclink = "<a href=\"_httptext_";
+    else doclink = "<a href=\"_httpbrowse_";
+    if (args["x"] == "1") doclink += "&x=1";
+    
+    return_text += "<tr>" + tab + "<td valign=top>";
+    if (is_top_level(*section) && args["x"] == "1") {
+      return_text += "<a href=\"\" onClick = \"close_detach()";
+    } else {
+      if (args["g"][1] == '0' || is_top_level(*section) ||
+      !are_same_chapter(booksection, *section) ||
+      !info.c.empty()) {
+    return_text += doclink + "d=" + classification;
+    return_text += "." + *section + "&a=" + pagetype;
+      } else {
+    return_text += "<a href=\"#";
+    return_text += count;
+    count ++;
+      }
+    }
+    return_text += "\">" + icon + "</a></td>";
+    return_text += "<td colspan=" + text_t(tabsleft);
+    return_text += "><_font_>" + info.t + "</font>";
+    return_text += "</td></tr>\n";
+    
+    section ++;
+  }
+  return_text += "</table>\n";
+  return_text += "</td></tr></table>\n";
+}
+
+
+void browseclass::get_parents_toc (cgiargsclass &args, const vector<text_t> &parents,
+                   gdbmclass &gdbm, int &tabcount, int &colnum,
+                   text_t &return_text) {  
+
+  text_t section, tab, icon, doclink;
+  gdbm_info info;
+
+  vector<text_t>::const_iterator thisparent = parents.begin();
+  vector<text_t>::const_iterator end = parents.end();
+
+  while (thisparent != end) {
+    text_t icontabs;
+    section.clear();
+    tab.clear();
+    
+    // get info on this parent from gdbm
+    if (is_book(*thisparent)) get_book(*thisparent, section);
+    else section = *thisparent;
+    gdbm.getinfo(section, args["c"], info);
+    
+    // set up icon for this parent
+    icon = "_iconopenfolder_";
+    if (!is_book(*thisparent)) icon = "_iconopenbookshelf_";
+    else if (is_top_level(*thisparent)) icon = "_iconopenbook_";
+    
+    for (int j = 0; j < tabcount; j++) {
+      icontabs += "_icontab_";
+    } 
+     
+    if (!icontabs.empty()) {
+      tab = "<td valign=top";
+      if (tabcount > 1) tab += " colspan=" + text_t(tabcount);
+      tab += ">" + icontabs + "</td>";
+    }
+    tabcount ++;
+    
+    // set up url
+    if (is_book(*thisparent) && !is_top_level(*thisparent)) 
+      doclink = "<a href=\"_httptext_";
+    else doclink = "<a href=\"_httpbrowse_";
+    if (args["x"] == "1") doclink += "&x=1";
+    
+    if (is_top_level(*thisparent) && args["x"] == "1") {
+      return_text += "<tr>" + tab + "<td valign=top><a href=\"\" ";
+      return_text += "onClick = \"close_detach()\">" + icon + "</a></td>";
+    } else {
+      return_text += "<tr>" + tab + "<td valign=top>" + doclink + "&d=" + *thisparent;
+      return_text += "\">" + icon + "</a></td>";
+    }
+    return_text += "<td"; 
+    if (colnum > 1) return_text += " colspan=" + text_t(colnum);
+    return_text += "><_font_>" + info.t;
+    if (!info.a.empty()) return_text += " by " + info.a;
+    return_text += "</font>";
+    return_text += "</td></tr>\n";
+    colnum --;
+    thisparent ++;
+  }
+}
+
+void browseclass::get_siblings_toc (cgiargsclass &args, const vector<text_t> &siblings, 
+                    gdbmclass &gdbm, const text_t &booksection, 
+                    const text_t &classification, int &tabcount, 
+                    int &colnum, text_t &return_text) {
+  
+  text_t tab, section, icon, pointer, child, doclink;
+  int count = 1;
+  gdbm_info info;
+  
+  vector<text_t>::const_iterator thissibling = siblings.begin();
+  vector<text_t>::const_iterator sibend = siblings.end();
+  
+  while (thissibling != sibend) {
+    section.clear();
+
+    // get info on this sibling from gdbm
+    if (is_book(*thissibling)) get_book(*thissibling, section);
+    else section = *thissibling;
+    gdbm.getinfo(section, args["c"], info);
+
+    // set up icon for this sibling
+    icon = "_iconclosedfolder_";
+    if (!is_book(*thissibling)) icon = "_iconclosedbookshelf_";
+    else if (is_top_level(*thissibling)) icon = "_iconclosedbook_";
+    
+    // fit pointer into tabbing if current section
+    pointer = "_icontab_";
+    if (is_book(section)) {
+      if (section == booksection) pointer = "_iconpointer_";
+    } else if (section == classification) pointer = "_iconpointer_";
+    
+    text_t thesetabs;
+    for (int j = 0; j < (tabcount - 1); j++) {
+      thesetabs += "_icontab_";
+    } 
+    
+    tab = "<td valign=top";
+    if (tabcount > 1) tab += " colspan=" + text_t(tabcount);
+    tab += ">" + thesetabs + pointer + "</td>";
+    
+    if (info.c.empty()) {
+      // sibling is text document
+      icon = "_iconsmalltext_";
+      
+      // set up url
+      if (is_book(*thissibling) && !is_top_level(*thissibling)) 
+    doclink = "<a href=\"_httptext_";
+      else doclink = "<a href=\"_httpbrowse_";
+      if (args["x"] == "1") doclink += "&x=1";
+      
+      return_text += "<tr>" + tab + "<td valign=top>";
+      if (args["g"][1] == '0') {
+    return_text += doclink + "&d=" + *thissibling;
+      } else {
+    return_text += "<a href=\"#";
+    return_text += count;
+    count ++;
+      }
+      return_text += "\">" + icon + "</a></td><td";
+      if (colnum > 1) return_text += " colspan=" + text_t(colnum);
+      return_text += "><_font_>" + info.t;
+      if (!info.a.empty()) return_text += " by " + info.a;
+      return_text += "</font></td></tr>\n";
+    } else {
+      // sibling is closed book or folder so clicking 
+      // it should open contents
+      get_first_section(info.c, child);
+      
+      // get classification of child if it's a book
+      if (is_book(child)) {
+    text_t classif = classification;
+    // remove last part (i.e. '.n') from classification if current section is 
+    // a classification and sibling is a book
+    if (booksection.empty() && is_book(*thissibling)) {
+      get_parent_section(classif);
+    }
+    // if sibling is a classification it is the classification of its child
+    if (!is_book(*thissibling)) classif = *thissibling;
+    
+    child = classif + "." + child;
+      }
+
+      // set up url
+      if (is_book(child) && !is_top_level(child)) 
+    doclink = "<a href=\"_httptext_";
+      else doclink = "<a href=\"_httpbrowse_";
+      if (args["x"] == "1") doclink += "&x=1";
+      
+      return_text += "<tr>" + tab + "<td valign=top>" + doclink + "&d=" + child;
+      return_text += "\">" + icon + "</a></td><td";
+      if (colnum > 1) return_text += " colspan=" + text_t(colnum);
+      return_text += "><_font_>" + info.t;
+      if (!info.a.empty()) return_text += " by " + info.a;
+      return_text += "</font></td></tr>\n";
+    }
+    thissibling ++;
+  }  
+}
+
+
+
+// get_alphabet_links adds the html for the letter selection links to return_text
+void browseclass::get_alphabet_links (const text_t &classification, 
+                      const text_t &booksection, gdbmclass &gdbm, 
+                      const text_t &collection, text_t &return_text) {
+  
+  gdbm_info info;
+
+  text_t link = "<a href=\"_httpbrowse_&d=";
+  vector<text_t> classcontents;
+  text_t classt, firstcontent;
+  classt.push_back(classification[0]);
+    
+  return_text += "\n<p>\n";
+  return_text += "<table width=\"100%\" cellpadding=0 cellspacing=0 border=0>\n";
+  return_text += "<tr><td valign=top><center>\n";
+  return_text += "<_font_>\n";
+  
+  // get list of contents for this classification
+  gdbm.getinfo(classt, collection, info);
+  if (!info.c.empty()) {
+    splitstring(info.c, classcontents);
+    vector<text_t>::const_iterator here = classcontents.begin();
+    vector<text_t>::const_iterator end = classcontents.end();
+
+    while (here != end) {
+      gdbm.getinfo(*here, collection, info);
+      
+      if (*here == classification) {
+    return_text += "<b>" + info.t + "</b>&nbsp;&nbsp;&nbsp;";
+      } else {
+    if (!info.c.empty()) {
+      get_first_section(info.c, firstcontent);
+      return_text += link + *here + "." + firstcontent + "\">";
+      return_text += info.t + "</a>&nbsp;&nbsp;&nbsp;";
+    }
+      }
+      here ++;
+    }
+  }
+  return_text += "</font>\n";
+  return_text += "</center></td>\n</tr><tr>\n";
+}
+
+// get_arrows returns (in arrows) the html for the arrows to select 
+// next/previous section at same level. If there is no next/previous
+// section at current level then there'll be no arrow.
+void browseclass::get_arrows(text_t &docref, gdbmclass &gdbm, 
+                 const text_t &collection, text_t &arrows) {
+  text_t previous, next, firstcontent;
+  gdbm_info info;
+
+  arrows = "\n<table width=\"100%\" border=0 cellspacing=0 cellpadding=0>";
+  arrows += "<tr><td align=left>\n";
+  arrows += "<_font_>\n";
+
+  // get links to previous and next sections.
+  get_prev_next_links(docref, collection, previous, next);
+
+  // get html for previous link if it exists
+  gdbm.getinfo(previous, collection, info);
+  if (!info.c.empty()) {
+    get_first_section(info.c, firstcontent);
+    arrows += "<a href=\"_httpbrowse_&d=";
+    arrows += previous + "." + firstcontent + "\">";
+    arrows += "_iconalphless_</a>\n";
+  }
+
+  arrows += "</font>\n";
+  arrows += "</td><td align=right>\n";
+  arrows += "<_font_>\n";
+
+  // get html for next link if it exists
+  gdbm.getinfo(next, collection, info);
+  if (!info.c.empty()) {
+    get_first_section(info.c, firstcontent);
+    arrows += "<a href=\"_httpbrowse_&d=";
+    arrows += next + "." + firstcontent + "\">";
+    arrows += "_iconalphmore_</a>\n";
+  }
+  
+  arrows += "</font>\n";
+  arrows += "</td></tr></table>\n";
+}
+
+// get_prev_next_links returns (in previous and next) the sections previous to 
+// and next after docref (on the same level). These sections may not be 
+// defined in the infodb so calling function should check.
+
+void browseclass::get_prev_next_links (text_t docref, const text_t &collection, 
+                       text_t &previous, text_t &next) {
+  int prevnum, nextnum, thisnum;
+  text_t section;
+
+  get_parent_section(docref, section);
+
+  thisnum = section.getint();
+  prevnum = thisnum - 1;
+  nextnum = thisnum + 1;
+  
+  previous = docref + "." + text_t(prevnum);
+  next = docref + "." + text_t(nextnum);
+}
+
+// get contents returns a contents array of all contents below (and including)
+// the classification in expandlevel. 
+// it also returns (in totalcols) the total number of columns needed for 
+// a table of contents using contents
+void browseclass::get_contents (text_t expandlevel1, gdbmclass &gdbm, 
+                const text_t &collection, vector<text_t> &contents, 
+                int &totalcols) {
+
+  text_t expandlevel = expandlevel1;
+  
+  contents.erase(contents.begin(), contents.end());
+  totalcols = 0;
+  
+  vector<text_t> sections;
+  text_t section, book_top;
+  int cols;
+  gdbm_info info;
+
+  if (!is_top_level(expandlevel)) get_parent_section(expandlevel);
+  
+  sections.push_back(expandlevel);
+
+  while (!sections.empty()) {
+    section = sections.back();
+    sections.pop_back();
+    get_book (section, section);
+
+    contents.push_back(section);
+
+    // update number of columns needed for table
+    cols = count_dots(section) + 1;
+    if (cols > totalcols) totalcols = cols;
+
+    gdbm.getinfo(section, collection, info);
+    if (!info.c.empty()) {
+      vector<text_t> temp;
+      splitstring(info.c, temp);
+      while (!temp.empty()) {
+    sections.push_back(temp.back());
+    temp.pop_back();
+      }
+    }
+  }
+  // get top level of book and add to contents if not already there
+  get_book_top(expandlevel, book_top);
+
+  if (contents.front() != book_top) {
+    contents.insert(contents.begin(), book_top);
+  }
+}
+
+
+//////////////////////////////////////////////////////////////////////////////////////////////
+// get_links returns (in return_text) the html for the buttons to link to the next and 
+// previous sections
+
+void browseclass::get_links(cgiargsclass &args, gdbmclass &gdbm, text_t &return_text) {
+  
+  text_t doclink, classification, booksection;
+  text_t nextsibling, previoussibling, lastsibling;
+  vector<text_t> siblings;
+  gdbm_info info;
+  
+  seperate_parts(args["d"], gdbm, args["c"], classification, booksection);
+  
+  // don't want links at top levels
+  if (booksection.empty() || is_top_level(booksection)) return;
+  
+  text_t current_classification = classification + "." + booksection;
+  
+  return_text += "<table width=\"100%\" border=0 cellspacing=0 cellpadding=0>\n";
+  return_text += "<tr><td align=left>\n";
+  
+  get_siblings (classification, booksection, gdbm, args["c"], siblings);
+  
+  // get older and younger siblings if they exist
+  int found = 0;
+  vector<text_t>::const_iterator thissibling = siblings.begin();
+  vector<text_t>::const_iterator end = siblings.end();
+  while (thissibling != end) {
+    if (found) {
+      nextsibling = *thissibling;
+      break;
+    }
+    
+    if (*thissibling == current_classification) {
+      previoussibling = lastsibling;
+      found = 1;
+    }
+    lastsibling = *thissibling;
+    thissibling ++;
+  }
+  
+  // don't want 'next' arrow pointing to next sibling if current section
+  // has children
+  gdbm.getinfo(booksection, args["c"], info);
+  if (!info.c.empty()) nextsibling = current_classification;
+  
+  // set up the 'previous' arrow
+  
+  if (is_section_top(booksection)) {
+    // if this section is the top of any section in line with
+    // top of book there'll be no 'previous' arrow 
+    // (i.e. B.n.1, B.n.1.1, B.n.1.1.1 etc.)
+  } else {
+    // get parents older sibling if no older sibling of own 
+    text_t sec = booksection;
+    while (previoussibling.empty()) {
+      vector<text_t> parentsiblings;
+      gdbm.getinfo(sec, args["c"], info); // info on this section
+      text_t last, parent = info.p;
+      gdbm.getinfo(parent, args["c"], info); // info on parent
+      gdbm.getinfo(info.p, args["c"], info); // info on grandparent
+      splitstring(info.c, parentsiblings); // now have parents siblings
+      
+      vector<text_t>::const_iterator thisuncle = parentsiblings.begin();
+      vector<text_t>::const_iterator end = parentsiblings.end();
+      
+      while (thisuncle != end) {
+    if (*thisuncle == parent) {
+      previoussibling = last;
+      break;
+    }
+    last = *thisuncle;
+    thisuncle ++;
+      }
+      sec = parent;
+    }
+    
+    // if previous section has contents then we need to link to the last
+    // of those contents
+    text_t prev; // use this in case previoussibling contains classification
+    get_book(previoussibling, prev);
+    gdbm.getinfo(prev, args["c"], info);
+    while (!info.c.empty()) {
+      vector<text_t> contents;
+      splitstring(info.c, contents);
+      previoussibling = contents.back();
+      gdbm.getinfo(previoussibling, args["c"], info);
+    }
+    
+    if (previoussibling[0] == 'B') previoussibling = classification + "." + previoussibling;
+  }
+  
+  
+  // set up the 'next' arrow
+  text_t sec = booksection;
+  // if no younger siblings get parents younger siblings
+  while (nextsibling.empty()) {
+    gdbm.getinfo(sec, args["c"], info);
+    text_t parent = info.p;
+    gdbm.getinfo(parent, args["c"], info); // parent info
+    if (!info.p.empty()) {
+      vector<text_t> parentsiblings;
+      gdbm.getinfo(info.p, args["c"], info); // grandparent info
+      splitstring(info.c, parentsiblings); // got parents siblings
+      
+      vector<text_t>::iterator thissibling = parentsiblings.begin();
+      vector<text_t>::iterator end = parentsiblings.end();
+      int found = 0;
+      while(thissibling != end) {
+    if (found) {
+      nextsibling = *thissibling;
+      break;
+    }
+    if (*thissibling == parent) found = 1;
+    thissibling ++;
+      }
+      sec = parent;
+    } else {
+      // no more contents
+      break;
+    }
+  }
+  
+  if (!nextsibling.empty()) {
+    // if nextsibling still isn't set there are no more sections in the
+    // book and so no 'next' arrow
+    
+    // if next section has contents we want to link to the first
+    // of those contents
+    text_t next;
+    get_book(nextsibling, next);
+    gdbm.getinfo(next, args["c"], info);
+    while (!info.c.empty()) {
+      get_first_section(info.c, nextsibling);
+      gdbm.getinfo(nextsibling, args["c"], info);
+    }
+    if (nextsibling[0] == 'B') nextsibling = classification + "." + nextsibling;
+  }
+  
+  // html for 'previous' arrow
+  if (!previoussibling.empty()) {
+    if (is_book(previoussibling) && !is_top_level(previoussibling)) 
+      doclink = "<a href=\"_httptext_";
+    else doclink = "<a href=\"_httpbrowse_";
+    if (args["x"] == "1") doclink += "&x=1";
+    
+    return_text += doclink + "&d=" + previoussibling + "\">_iconless_</a>\n";
+  }
+  
+  return_text += "</td><td align=right>\n";
+  
+  // html for 'next' arrow
+  if (!nextsibling.empty()) {
+    if (is_book(nextsibling) && !is_top_level(nextsibling))
+      doclink = "<a href=\"_httptext_";
+    else doclink = "<a href=\"_httpbrowse_";
+    if (args["x"] == "1") doclink += "&x=1";
+    
+    return_text += doclink + "&d=" + nextsibling + "\">_iconmore_</a>\n";
+  }
+  
+  return_text += "</td></tr></table>\n";
+}
+
+// get_contents_arr returns an array containing the classifications of all the sections
+// in the book mentioned in targetdoc
+
+void browseclass::get_contents_arr(cgiargsclass &args, gdbmclass &gdbm, 
+                   vector<text_t> &contents_arr) {
+  text_t booksection;
+  int totalcols = 0;
+  get_book(args["d"], booksection);
+  get_contents (booksection, gdbm, args["c"], contents_arr, totalcols);
+}
+
+
+// sorts an array of sections alphabetically (i.e. by title, author depending
+// on what classification is)
+void browseclass::sort_array (vector<text_t> &array, gdbmclass &gdbm, 
+                  const text_t &collection, const text_t classification) {
+
+  gdbm_info info;
+  char **tmparray = NULL;
+  int len = 0, i;
+  text_t tmpstr;
+  
+  vector<text_t>::const_iterator here = array.begin();
+  vector<text_t>::const_iterator end = array.end();
+  
+  while (here != end) {
+    text_t key;
+    if (is_book(*here)) get_book(*here, key);
+    else key = *here;
+
+    gdbm.getinfo(key, collection, info);
+    if (classification[0] == 'T') {
+      
+      alphabetize_string_english(info.t);
+      info.t += ":#:" + *here;
+      tmparray = string_add(tmparray, &len, info.t.getcstr());
+
+    } else {
+      alphabetize_string_name(info.a);
+      info.a += ":#:" + *here;
+      tmparray = string_add(tmparray, &len, info.a.getcstr());
+    }
+    here ++;
+  }
+  string_sort (tmparray, len);
+
+  array.clear();
+  for (i = 0; i < len; i ++) {
+    tmpstr = get_section_str(tmparray[i]);
+    array.push_back(tmpstr);
+  }
+  string_free(tmparray, len);
+}
+

trunk/gsdl/src/library/browse.h

@@ -14 +14 @@
   virtual ~browseclass () {}
 
-  virtual void get_browse_bar(const text_t &targetdoc, text_t &return_text) {}
-
+  virtual void get_browse_bar(const text_t &targetdoc, text_t &return_text);
   virtual void get_top_locator(cgiargsclass &args, gdbmclass &gdbm, int oversize, text_t &return_text) {}
-  virtual void get_links(cgiargsclass &args, gdbmclass &gdbm, text_t &return_text) {}
-  virtual void get_contents_arr(cgiargsclass &args, gdbmclass &gdbm, vector<text_t> &contents_arr) {}
+  virtual void get_links(cgiargsclass &args, gdbmclass &gdbm, text_t &return_text);
+  virtual void get_contents_arr(cgiargsclass &args, gdbmclass &gdbm, vector<text_t> &contents_arr);
 
 protected:
 
+  virtual void get_list_toc (vector<text_t> &secarray, text_t &collection,
+                 gdbmclass &gdbm, text_t &return_text);
+  virtual void get_page_toc (cgiargsclass &args, const text_t &booksection, 
+                 const text_t &classification, const text_t &class_string,
+                 gdbmclass &gdbm, text_t &return_text);
+  virtual void get_standard_toc(cgiargsclass &args, text_t &booksection, 
+                const text_t &classification, gdbmclass &gdbm, 
+                text_t &return_text);
   virtual void get_expanded_toc(cgiargsclass &args, text_t &booksection, 
                 const text_t &classification, gdbmclass &gdbm, 
-                text_t &return_text) {}
-  virtual void get_standard_toc(cgiargsclass &args, text_t &booksection, 
-                const text_t &classification, gdbmclass &gdbm, 
-                text_t &return_text) {}
-  virtual void get_alphabet_links (const text_t &booksection, gdbmclass &gdbm, 
-                   const text_t &collection, text_t &return_text) {}
-  virtual void get_title_arrows(text_t classification, gdbmclass &gdbm, 
-                const text_t &collection, text_t &alphabet_arrows) {}
-  virtual void get_contents (text_t expandlevel, gdbmclass &gdbm, 
+                text_t &return_text);
+  virtual void get_parents_toc (cgiargsclass &args, const vector<text_t> &parents,
+                gdbmclass &gdbm, int &tabcount, int &colnum,
+                text_t &return_text);
+  virtual void get_siblings_toc (cgiargsclass &args, const vector<text_t> &siblings, 
+                 gdbmclass &gdbm, const text_t &booksection, 
+                 const text_t &classification, int &tabcount, 
+                 int &colnum, text_t &return_text);
+  virtual void get_alphabet_links (const text_t &classification, 
+                   const text_t &booksection, gdbmclass &gdbm, 
+                   const text_t &collection, text_t &return_text);
+  virtual void get_arrows(text_t &docref, gdbmclass &gdbm, 
+              const text_t &collection, text_t &arrows);
+  virtual void get_prev_next_links (text_t docref, const text_t &collection, 
+                    text_t &previous, text_t &next);
+  virtual void get_contents (text_t expandlevel1, gdbmclass &gdbm, 
                  const text_t &collection, vector<text_t> &contents, 
-                 int &totalcols) {}
-
+                 int &totalcols);
+  virtual void sort_array (vector<text_t> &array, gdbmclass &gdbm, 
+               const text_t &collection, const text_t classification);
 };
 

trunk/gsdl/src/library/locateinfo.cpp

@@ -5 +5 @@
              text_t &ttidxsuffix)
 {
-  ttidxsuffix = "collect";
 
-#ifdef __WIN32__
-  ttidxsuffix += "\\";
-#else
-  ttidxsuffix += "/";
-#endif
+  // new directory structure
+  //  ttidxsuffix = "collect";
 
-  ttidxsuffix += collection;
+  //#ifdef __WIN32__
+  //ttidxsuffix += "\\";
+  //#else
+  //ttidxsuffix += "/";
+  //#endif
+
+  //ttidxsuffix += collection;
+
 
 #ifdef __WIN32__
@@ -34 +37 @@
             text_t &tttxtsuffix)
 {
-  tttxtsuffix = "collect";
+  // new directory structure
+  //  tttxtsuffix = "collect";
 
-#ifdef __WIN32__
-  tttxtsuffix += "\\";
-#else
-  tttxtsuffix += "/";
-#endif
+  //#ifdef __WIN32__
+  //tttxtsuffix += "\\";
+  //#else
+  //tttxtsuffix += "/";
+  //#endif
 
-  tttxtsuffix += collection;
+  //tttxtsuffix += collection;
 
 #ifdef __WIN32__