text of the given bib entry.
   * URLs are replaced by HTML links.
   */
  function toEntryUnformatted() {
    $result = "";
    $result .= '
'; // pre is nice when it is embedded with no CSS available
    $entry = str_replace('<','<',$this->getFullText());
    if ($this->hasField('url')) {
      $url = $this->getField('url');
      // this is not a parsing but a simple replacement
      $entry = str_replace($url,''.$url.'', $entry);
    }

    $result .=  $entry;
    $result .=  '
';
    return $result;
   }

   /**
   * Gets the raw text of the entry (crossref + strings + entry)
   */
  function getFullText() {
    $s = '';
    // adding the crossref if necessary
    if ($this->crossref!=null) { $s .= $this->crossref->getFullText()."\n";}
    $s.=$this->getConstants();
    $s.=$this->getText();
    return $s;
  }
}


/** this function encapsulates the user-defined name for bib to HTML*/
function bib2html(&$bibentry) {
  $function = BIBLIOGRAPHYSTYLE;
  return $function($bibentry);
}

/**bibtexbrowser uses this function which encapsulates the user-defined sections*/
function _DefaultBibliographySections() {
  $function = BIBLIOGRAPHYSECTIONS;
  return $function();
}

/** the default sections */
function DefaultBibliographySections() {
return  
  array(
  // Books
    array(
      'query' => array(Q_TYPE=>'book'),
      'title' => 'Books'
    ),
  // Journal / Bookchapters
    array(
      'query' => array(Q_TYPE=>'article|incollection'),
      'title' => 'Refereed Articles and Book Chapters'
    ),
  // conference papers
    array(
      'query' => array(Q_TYPE=>'inproceedings|conference',Q_EXCLUDE=>'workshop'),
      'title' => 'Refereed Conference Papers'
    ),
  // workshop papers
    array(
      'query' => array(Q_TYPE=>'inproceedings',Q_SEARCH=>'workshop'),
      'title' => 'Refereed Workshop Papers'
    ),
  // misc and thesis
    array(
      'query' => array(Q_TYPE=>'misc|phdthesis|mastersthesis|bachelorsthesis|techreport'),
      'title' => 'Other Publications'
    )
  );
}


?>getTitle();
  $type = $bibentry->getType();

  // later on, all values of $entry will be joined by a comma
  $entry=array();

  // title
  // usually in bold: .bibtitle { font-weight:bold; }
  $title = ''.$title.'';
  if ($bibentry->hasField('url')) $title = ' '.$title.'';
  

  // author
  if ($bibentry->hasField('author')) {
    $coreInfo = $title . ' ('.$bibentry->getFormattedAuthorsImproved().')';}
  else $coreInfo = $title;

  // core info usually contains title + author
  $entry[] = $coreInfo;

  // now the book title
  $booktitle = '';
  if ($type=="inproceedings") {
      $booktitle = 'In '.$bibentry->getField(BOOKTITLE); }
  if ($type=="incollection") {
      $booktitle = 'Chapter in '.$bibentry->getField(BOOKTITLE);}
  if ($type=="inbook") {
      $booktitle = 'Chapter in '.$bibentry->getField('chapter');}
  if ($type=="article") {
      $booktitle = 'In '.$bibentry->getField("journal");}
  if (($type=="misc") && $bibentry->hasField("note")) {
    $booktitle = $bibentry->getField("note");}

  //// we may add the editor names to the booktitle
  $editor='';
  if ($bibentry->hasField(EDITOR)) {
    $editor = $bibentry->getFormattedEditors();
  }
  if ($editor!='') $booktitle .=' ('.$editor.')';
  // end editor section

  // is the booktitle available
  if ($booktitle!='') {
    $entry[] = ''.$booktitle.'';
  }


  $publisher='';
  if ($type=="phdthesis") {
      $publisher = 'PhD thesis, '.$bibentry->getField(SCHOOL);
  }
  if ($type=="mastersthesis") {
      $publisher = 'Master\'s thesis, '.$bibentry->getField(SCHOOL);
  }
  if ($type=="bachelorsthesis") {
      $publisher = 'Bachelor\'s thesis, '.$bibentry->getField(SCHOOL);
  }
  if ($type=="techreport") {
      $publisher = 'Technical report, '.$bibentry->getField("institution");
  }
  
  if ($type=="misc") {
      $publisher = $bibentry->getField('howpublished');
  }

  if ($bibentry->hasField("publisher")) {
    $publisher = $bibentry->getField("publisher");
  }

  if ($publisher!='') $entry[] = ''.$publisher.'';


  if ($bibentry->hasField('volume')) $entry[] =  "volume ".$bibentry->getField("volume");


  if ($bibentry->hasField(YEAR)) $entry[] = $bibentry->getYear();

  $result = implode(", ",$entry).'.';

  // some comments (e.g. acceptance rate)?
  if ($bibentry->hasField('comment')) {
      $result .=  " (".$bibentry->getField("comment").")";
  }
  if ($bibentry->hasField('note')) {
      $result .=  " (".$bibentry->getField("note").")";
  }

  // add the Coin URL
  $result .=  "\n".$bibentry->toCoins();

  return $result;
}


?> $val) {
      if($key == '_author') { $key = 'author'; }
      $array_param[$key]=$key .'='. urlencode($val);
 }
 return implode("&",$array_param);
}

/**
 * Given a query, an array of key value pairs, returns a href string
 * of the form: href="?bib=testing.bib&search=JML.
 */
function makeHref($query = NULL) {
  return 'href="?'. createQueryString($query) .'"';
}

/**
 * Returns the last name of an author name.
 */
function getLastName($author){
    list($firstname, $lastname) = splitFullName($author);
    return $lastname;
}

/**
 * Returns the splitted name of an author name as an array. The argument is assumed to be
 *  or .
 */
function splitFullName($author){
    $author = trim($author);
    // the author format is "Joe Dupont"
    if (strpos($author,',')===false) {
      $parts=explode(' ', $author);
      // get the last name
      $lastname = array_pop($parts);
      $firstname = implode(" ", $parts);
    }
    // the author format is "Dupont, J."
    else {
      $parts=explode(',', $author);
      // get the last name
      $lastname = str_replace(',','',array_shift($parts));
      $firstname = implode(" ", $parts);
    }
  return array(trim($firstname), trim($lastname));
}


/** New undocumented feature, used by Benoit Baudry
 * see http://www.irisa.fr/triskell/perso_pro/bbaudry/publications.php 
 *
 * $_GET['library']=1;
 * $_GET['bib']='metrics.bib';
 * $_GET['all']=1;
 * include( 'bibtexbrowser.php' );
 * setDB();
 * new IndependentYearMenu();
 * new Dispatcher();
 *
 */
class IndependentYearMenu  {
  function IndependentYearMenu() { 
    if (!isset($_GET[Q_DB])) {die('Did you forget to call setDB() before instantiating this class?');}
    $yearIndex = $_GET[Q_DB]->yearIndex();
    echo '
Year: ';
    $formatedYearIndex = array();
    $formatedYearIndex[] = ''.*')).'>All';    
    foreach($yearIndex as $year) {
      $formatedYearIndex[] = '$year)).'>'.$year.'';
    }
    
    // by default the separator is a |
    echo implode('|',$formatedYearIndex);
    echo '
';
  }
}

/** Class to encapsulates the header formatting and the powered by footer  */
class BibtexBrowserDisplay {
  /** the title */
  var $title;

  function getTitle() { return $this->title; }

  function display() { /* unimplemented */ }

  /** returns the url of this display (e.g. base on the query)*/
  function getURL() { return '';}

  /** returns the url of the RSS  */
  function getRSS() { return '';}

  /** Returns the powered by part */
  function poweredby() {
    $poweredby = "\n".'
';
    $poweredby .= '';
    $poweredby .= 'Powered by bibtexbrowser';
    $poweredby .= '
'."\n";
    return $poweredby;
   }

  function  formatedHeader() { return "
{$this->title}
\n";}

  /** Adds a touch of AJAX in bibtexbrowser to display bibtex entries inline.
   * It uses the HIJAX design pattern: the Javascript code fetches the normal bibtex HTML page
   * and extracts the bibtex.
   * In other terms, URLs and content are left perfectly optimized for crawlers 
   * Note how beautiful is this piece of code thanks to JQuery.
   */
  function javascript() {
  // we use jquery with the official content delivery URLs
  // Microsoft and Google also provide jquery with their content delivery networks
?> 
db =$db;
  }

  /** function called back by HTMLWrapper */
  function display() {
  echo $this->searchView().'
';
  echo $this->typeVC().'
';
  echo $this->yearVC().'
';
  echo $this->authorVC().'
';
  echo $this->tagVC().'
';
  }

  /** Displays the title in a table. */
  function titleView() {
    ?>
    

      

        
Generated from 
      
    
    
    

      
      
      

      
    
    db->getTypes() as $type) {
        $types[$type] = $type;
      }
    // retreive or calculate page number to display
    if (isset($_GET[Q_TYPE_PAGE])) {
      $page = $_GET[Q_TYPE_PAGE];
    }
    else $page = 1;

    $this->displayMenu('Types', $types, $page, TYPES_SIZE, Q_TYPE_PAGE, Q_TYPE);
  }

  /** Displays and controls the authors menu in a table. */
  function authorVC() {
    // retrieve authors list to display
      $authors = $this->db->authorIndex();

    // determine the authors page to display
    if (isset($_GET[Q_AUTHOR_PAGE])) {
      $page = $_GET[Q_AUTHOR_PAGE];
    }
    else $page = 1;


    $this->displayMenu('Authors', $authors, $page, AUTHORS_SIZE, Q_AUTHOR_PAGE,
         Q_AUTHOR);
  }

  /** Displays and controls the tag menu in a table. */
  function tagVC() {
    // retrieve authors list to display
      $tags = $this->db->tagIndex();

    // determine the authors page to display
    if (isset($_GET[Q_TAG_PAGE])) {
      $page = $_GET[Q_TAG_PAGE];
    }  else $page = 1;


    if (count($tags)>0) $this->displayMenu('Keywords', $tags, $page, TAGS_SIZE, Q_TAG_PAGE,
         Q_TAG);
  }

  /** Displays and controls the tag menu in a table. */
  function yearVC() {
    // retrieve authors list to display
      $years = $this->db->yearIndex();

    // determine the authors page to display
    if (isset($_GET[Q_YEAR_PAGE])) {
      $page = $_GET[Q_YEAR_PAGE];
    }
else $page = 1;


    $this->displayMenu('Years', $years, $page, YEAR_SIZE, Q_YEAR_PAGE,
         Q_YEAR);
  }

  /** Displays the main contents . */
  function mainVC() {
      $this->display->display();
  }

  /** Displays a list menu in a table.
   *
   * $title: title of the menu (string)
   * $list: list of menu items (string)
   * $page: page number to display (number)
   * $pageSize: size of each page
   * $pageKey: URL query name to send the page number to the server
   * $targetKey: URL query name to send the target of the menu item
   */
  function displayMenu($title, $list, $page, $pageSize, $pageKey,
         $targetKey) {
    $numEntries = count($list);
    $startIndex = ($page - 1) * $pageSize;
    $endIndex = $startIndex + $pageSize;
    ?>
    

      

        

        
        

          

            

            

                menuPageBar($pageKey, $numEntries, $page,
           $pageSize, $startIndex, $endIndex);?>
          
        
        
      
      

        

          displayMenuItems($list, $startIndex, $endIndex,
     $targetKey); ?>
        
      
    
   0) {
      $href = makeHref(array($queryKey => $page - 2,'menu'=>''));
      $result .= '«\n";
    }*/

    // (1 page) reverse (<)
    if ($start > 0) {
      $href = makeHref(array($queryKey => $page - 1,'menu'=>''));
      $result .= '[prev]\n";
    }

    // (1 page) forward (>)
    if ($end < $numEntries) {
      $href = makeHref(array($queryKey => $page + 1,'menu'=>''));
      $result .= '[next]\n";
    }

    /*// commented after the usability remarks of Benoit Combemale
    // fast (2 pages) forward (>>)
    if (($end + $pageSize) < $numEntries) {
      $href = makeHref(array($queryKey => $page + 2,'menu'=>''));
      $result .= '»\n";
    }*/
    return $result;
  }

  /**
   * Displays menu items (anchors) from the start index (inclusive) to
   * the end index (exclusive). For each menu, the following form of
   * string is printed:
   *
   * 
   *    Cheon, Yoonsik
   * 

   */
  function displayMenuItems($items, $startIndex, $endIndex, $queryKey) {
    $index = 0;
    foreach ($items as $key => $item) {
      if ($index >= $startIndex && $index < $endIndex) {
 $href = makeHref(array($queryKey => $key));
 echo ''. $item ."\n";
 echo "
\n";
      }
      $index++;
    }
  }
}

/** transforms an array representing a query into a formatted string */
function query2title(&$query) {
    $headers = array();
    foreach($query as $k=>$v) {
      if($k == '_author') { $k = 'author'; }
      if($k == 'type') { $v = substr($v,1,strlen($v)-2); }
      $headers[$k] = ucwords($k).': '.ucwords($v);
  }
    // special cases
    if (isset($headers[Q_ALL])) $headers[Q_ALL] = 'Publications in '.$_GET[Q_FILE];
    if (isset($headers[Q_AUTHOR])) $headers[Q_AUTHOR] = 'Publications of '.$_GET[Q_AUTHOR];
    return join(' & ',$headers);
}


/** Class to display a result as a set of pages. */
class PagedDisplay extends BibtexBrowserDisplay {
  /** the bib entries to display. */
  var $result;

  /** the page number to display. */
  var $page;

  /** the total number of pages to display. */
  var $noPages;

  /** the start index to display. */
  var $startIndex;

    /** the end index to display. */
  var $endIndex;

  /** the content strategy (cf. pattern strategy) */
  var $contentStrategy;

  /** the query to reinject in links to different pages */
  var $filter;

  /** Creates an instance with the given entries and header. */
  function PagedDisplay(&$result, $filter) {
    $this->result = $result;
    $this->filter = $filter;
    // requesting a different page of the result view?
    if (isset($_GET[Q_RESULT])) {
      $this->setPage($_GET[Q_RESULT]);
    } else $this->page = 1;
    $this->setTitle();
    $this->contentStrategy = new DefaultContentStrategy();
  }

  /** sets the $this->title of BibtexBrowserDisplay based on the $filter */
  function setTitle() {
    $this->title = query2title($this->filter);
    if ($this->page>1) $this->title.=' - page '.$this->page;
  }

  /** Sets the page number to display. */
  function setPage($page) {
    $this->page = $page;
  }

  /** overrides */
  function  formatedHeader() { return '
'.$this->title.' '.createRSSLink($this->filter).'
';}

  /** overrides */
  function getURL() { return '?'.createQueryString($this->filter);}

  /** overrides */
  function getRSS() { return BIBTEXBROWSER_URL.'?'.createQueryString($this->filter).'&rss';}

  /** Displays the entries preceded with the header. */
  function display() {

    $page = $this->page;

    // print error message if no entry.
    if (empty($this->result)) {
      echo "No match found!\n";
      return;
    }

    $this->noPages = ceil(count($this->result) / PAGE_SIZE);

      /** Displays the header stringg. */
    echo $this->formatedHeader();

    if ($this->noPages>1) $this->displayPageBar($this->noPages, $page);

    $this->startIndex = ($page - 1) * PAGE_SIZE;
    $this->endIndex =$this->startIndex + PAGE_SIZE;

    $this->contentStrategy->display($this);
    if ($this->noPages>1) $this->displayPageBar($this->noPages, $page);

    echo $this->poweredby();
    
    if (BIBTEXBROWSER_USE_PROGRESSIVE_ENHANCEMENT) {
      $this->javascript();
    }

  }

  function isDisplayed($index) {
    if ($index >= $this->startIndex && $index < $this->endIndex) return true;
    return false;
  }


  /** Displays a page bar consisting of clickable page numbers. */
  function displayPageBar($noPages, $page) {

    // bug found by benoit, first we have to reset the q_result
    $this->filter[Q_RESULT] = 1;

    $barSize = 10; // *2
    $start = ($page - $barSize) > 0 ? $page - $barSize : 1;
    $end = min($noPages, $start + $barSize * 2);

    echo '
';

    // fast reverse (<<)
    if ($start - $barSize*2 > 0) {
      $this->filter[Q_RESULT] = $page - $barSize * 2;
      $href = makeHref($this->filter);
      echo '[«]";
    }

    // reverse (<)
    if ($start > 1) {
      $this->filter[Q_RESULT] =$start - 1;
      $href = makeHref($this->filter);
      echo '[<]";
    }

    // page numbers
    foreach (range($start, $end) as $i) {
      // default page is #1
      // we don't duplicate URLs
      if ($i > 1) $this->filter[Q_RESULT] = $i;
      $href = makeHref($this->filter);
      if ($i == $page) {
        // don't make links for current page
 echo '['. $i .']';
      } else {
 echo '['. $i .']';
      }
    }

    // forward (>)
    if ($end < $noPages) {
      $this->filter[Q_RESULT] = $end + 1;
      $href = makeHref($this->filter);
      echo '[>]";
    }

    // fast forward (>>)
    if (($end + $barSize*2) <= $noPages) {
      $this->filter[Q_RESULT] =$end + $barSize * 2;
      $href = makeHref($this->filter);
      echo '[»]\n";
    }
    //print_r($this->filter);
    echo '
';
  }
}

/** creates an RSS link with text or image depending on the environment */
  function createRSSLink($filter) {
    // default label
    $label='[rss]';
    // auto adaptive code :-)
    //if (is_file('rss.png')) $label='';
    return ''.$label.'';
}


/**
  * Displays the summary information of each bib entries of the
  * current page. For each entry, this method displays the author,
  * title; the bib entries are displayed grouped by the
  * publication years. If the bib list is empty, an error message is
  * displayed.
  */
class DefaultContentStrategy  {

  /** $display: an instance of PagedDisplay */
  function display(&$display) {
    // create a year -> entries map to display by years
    $years = array();
    foreach ($display->result as $e) {
      $y =  trim($e->getField(YEAR));
      $years[$y][$e->getKey()] = $e;
    }
    krsort($years);

    ?>

    result)-(($display->page-1)*PAGE_SIZE);
    foreach ($years as $year => $entries) {


      if ($display->isDisplayed($index)) {
      ?>
      isDisplayed($index)) {
          $bib->id = $refnum--;
          $bib->toTR();
        }
        $index++;

      } // end foreach
    }
    ?>
    
    
    Sorry, this bib entry does not exist.
    Back to bibtexbrowser
    query=$query;
    $this->db=new BibDataBase();
    $this->db->bibdb = $entries;
    $this->title = query2title($query);
  }

  /** overrides */
  function  formatedHeader() { return '
'.$this->title.' '.createRSSLink($this->query).'
';}


  /** transforms a query to HTML 
   * $ query is an array (e.g. array(Q_TYPE=>'book'))
   * $title is a string, the title of the section
   */
  function search2html($query, $title) {
    $entries = $this->db->multisearch($query);
    if (count($entries)>0) {
    echo "\n".'
'.$title.'
'."\n";
    echo ''."\n";
    foreach ($entries as $bib) {
        $bib->id = $bib->getYear();
        $bib->toTR();
    } // end foreach
    echo '';
    }

  }
  
  function display() {
    echo $this->formatedHeader();
    foreach (_DefaultBibliographySections() as $section) {
      $this->search2html($section['query'],$section['title']);
    }

    echo $this->poweredby();
    
    if (BIBTEXBROWSER_USE_PROGRESSIVE_ENHANCEMENT) {
      $this->javascript();
    }

  }

}




/** Class to display a single bib entry.
 * This view is optimized for Google Scholar
 * */
class BibEntryDisplay extends BibtexBrowserDisplay {

  /** the bib entry to display */
  var $bib;

  /** Creates an instance with the given bib entry and header.
   * It the object is an instance of BibIndexEntry, it may be
   * mutated to read the rest of the fields.
   */
  function BibEntryDisplay(&$bibentry) {
    $this->bib = $bibentry;
    $this->title = $this->bib->getTitle().' (bibtex)';
    //$this->title = $this->bib->getTitle().' (bibtex)'.$this->bib->getUrlLink();
  }


  function display() {
    // we encapsulate everything so that the output of display() is still valid XHTML
    echo '
';
    echo $this->bib->toCoins();
    echo $this->formatedHeader();
    echo $this->bib->toEntryUnformatted();
    //echo $this->bib->getUrlLink();
    echo $this->poweredby();
    echo '
';
  }

  /** Creates metadata for Google Scholar
   * + a description
   * @see http://scholar.google.com/intl/en/scholar/inclusion.html
   * @see http://www.monperrus.net/martin/accurate+bibliographic+metadata+and+google+scholar
   * */
  function metadata() {
    $result=array();
    
    if (METADATA_GS) {
    // the description may mix with the Google Scholar tags
    // we remove it
    // $result[] = array('description',trim(strip_tags(str_replace('"','',bib2html($this->bib)))));
    $result[] = array('citation_title',$this->bib->getTitle());
    $authors = $this->bib->getArrayOfCommaSeparatedAuthors();
    $result[] = array('citation_authors',implode("; ",$authors));
    foreach($authors as $author) {
      $result[] = array('citation_author',$author);
    }
    $result[] = array('citation_date',$this->bib->getYear());

    // this page
    $result[] = array('citation_abstract_html_url','http://'.$_SERVER['HTTP_HOST'].($_SERVER['SERVER_PORT']=='80'?'':$_SERVER['SERVER_PORT']).str_replace('&','&',$_SERVER['REQUEST_URI']));
    
    if ($this->bib->hasField("publisher")) {
      $result[] = array('citation_publisher',$this->bib->getPublisher());
    }

    // BOOKTITLE: JOURNAL NAME OR PROCEEDINGS
    if ($this->bib->getType()=="article") { // journal article
      $result[] = array('citation_journal_title',$this->bib->getField("journal"));
      $result[] = array('citation_volume',$this->bib->getField("volume"));
      if ($this->bib->hasField("issue")) {
        $result[] = array('citation_issue',$this->bib->getField("issue"));
      }
      if ($this->bib->hasField("issn")) {
        $result[] = array('citation_issue',$this->bib->getField("issn"));
      }
    } 

    if ($this->bib->getType()=="inproceedings" || $this->bib->getType()=="conference") {
       $result[] = array('citation_conference_title',$this->bib->getField(BOOKTITLE));
       $result[] = array('citation_conference',$this->bib->getField(BOOKTITLE));
    }

    if ($this->bib->getType()=="phdthesis"
         || $this->bib->getType()=="mastersthesis"
         || $this->bib->getType()=="bachelorsthesis"
       )
    {
       $result[] = array('citation_dissertation_institution',$this->bib->getField('school'));
    }

    if ($this->bib->getType()=="techreport"
         && $this->bib->hasField("number")
       )
    {
       $result[] = array('citation_technical_report_number',$this->bib->getField('number'));
    }

    if ($this->bib->getType()=="techreport"
         && $this->bib->hasField("institution")
       )
    {
       $result[] = array('citation_technical_report_institution',$this->bib->getField('institution'));
    }

    // generic
    if ($this->bib->hasField("doi")) {
      $result[] = array('citation_doi',$this->bib->getField("doi"));
    }

    if ($this->bib->hasField("url")) {
      $result[] = array('citation_pdf_url',$this->bib->getField("url"));
    }
    }
    
    
    // we don't introduce yet another kind of bibliographic metadata
    // the core bibtex metadata will simply be available as json
    // now adding the pure bibtex with no translation
    //foreach ($this->bib->getFields() as $k => $v) {
    //  if (!preg_match("/^_/",$k)) {
    //    $result[] = array("bibtex:".$k,$v);  
    //  }
    //}

    
    // a fallback to essential dublin core
    // Dublin Core should not be used for bibliographic metadata
    // according to several sources 
    //  * Google Scholar: "Use Dublin Core tags (e.g., DC.title) as a last resort - they work poorly for journal papers"
    //  * http://reprog.wordpress.com/2010/09/03/bibliographic-data-part-2-dublin-cores-dirty-little-secret/
    // however it seems that Google Scholar needs at least DC.Title to trigger referencing
    // reference documentation: http://dublincore.org/documents/dc-citation-guidelines/
    if (METADATA_DC) {
    $result[] = array('DC.Title',$this->bib->getTitle());
    foreach($this->bib->getArrayOfCommaSeparatedAuthors() as $author) {
      $result[] = array('DC.Creator',$author);
    }
    $result[] = array('DC.Date',$this->bib->getYear());
    }

    // --------------------------------- BEGIN METADATA EPRINTS
    // and now adding eprints metadata
    // why adding eprints metadata?
    // because eprints is a well known bibliographic software and several crawlers/desktop software
    // use their metadata
    // unfortunately, the metadata is even less documented than Google Scholar citation_
    // reference documentation: the eprints source code (./perl_lib/EPrints/Plugin/Export/Simple.pm)
    // examples: conference paper: http://tubiblio.ulb.tu-darmstadt.de/44344/
    //           journal paper: http://tubiblio.ulb.tu-darmstadt.de/44344/
    if (METADATA_EPRINTS) {
    $result[] = array('eprints.title',$this->bib->getTitle());
    $authors = $this->bib->getArrayOfCommaSeparatedAuthors();
    foreach($authors as $author) {
      $result[] = array('eprints.creators_name',$author);
    }
    $result[] = array('eprints.date',$this->bib->getYear());

    if ($this->bib->hasField("publisher")) {
      $result[] = array('eprints.publisher',$this->bib->getPublisher());
    }

    if ($this->bib->getType()=="article") { // journal article
      $result[] = array('eprints.type','article');
      $result[] = array('eprints.publication',$this->bib->getField("journal"));
      $result[] = array('eprints.volume',$this->bib->getField("volume"));
      if ($this->bib->hasField("issue")) {
        $result[] = array('eprints.number',$this->bib->getField("issue"));}
    } 

    if ($this->bib->getType()=="inproceedings" || $this->bib->getType()=="conference") {
       $result[] = array('eprints.type','proceeding');
       $result[] = array('eprints.book_title',$this->bib->getField(BOOKTITLE));
    }

    if ($this->bib->getType()=="phdthesis"
         || $this->bib->getType()=="mastersthesis"
         || $this->bib->getType()=="bachelorsthesis"
       )
    {
       $result[] = array('eprints.type','thesis');
       $result[] = array('eprints.institution',$this->bib->getField('school'));
    }

    if ($this->bib->getType()=="techreport")
    {
       $result[] = array('eprints.type','monograph');
       if ($this->bib->hasField("number")) {
         $result[] = array('eprints.number',$this->bib->getField('number'));
       }
       if ($this->bib->hasField("institution")) {
         $result[] = array('eprints.institution',$this->bib->getField('institution'));
       }
    }

    // generic
    if ($this->bib->hasField("doi")) {
      $result[] = array('eprints.id_number',$this->bib->getField("doi"));
    }

    if ($this->bib->hasField("url")) {
      $result[] = array('eprints.official_url',$this->bib->getField("url"));
    }
    }
    // --------------------------------- END METADATA EPRINTS

    return $result;

  }
}

// ----------------------------------------------------------------------
// DATABASE MANAGEMENT
// ----------------------------------------------------------------------

/**
 * Abstraction of bibliographic database to contain a set of
 * bibliographic entries and maintain them.
 */
class BibDataBase {
  /** A hash table from keys (e.g. Goody1994) to bib entries (BibEntry instances). */
  var $bibdb;

  /** A hashtable of constant strings */
  var $stringdb;

  /** Creates a new database by parsing bib entries from the given
   * file. */
  function load($filename) {
    $db = new BibDBBuilder($filename, $this->bibdb, $this->stringdb);
    //print_r($parser);
    $this->bibdb = $db->builtdb;
    $this->stringdb = $db->stringdb;
    //print_r($this->stringdb);
  }

  /** Creates a new empty database */
  function BibDataBase() {
    $this->bibdb = array();
    $this->stringdb = array();
  }

  /** Returns all entries as an array. Each entry is an instance of
   * class BibEntry. */
  function getEntries() {
    return $this->bibdb;
  }
  /** tests wheter the database contains a bib entry with $key */
  function contains($key) {
    return isset($this->bibdb[$key]);
  }
  /** Returns all entries categorized by types. The returned value is
   * a hashtable from types to arrays of bib entries.
   */
  function getEntriesByTypes() {
    $result = array();
    foreach ($this->bibdb as $b) {
      $result[$b->getType()][] = $b;
    }
    return $result;
  }

  /** Returns an array containing all the bib types (strings). */
  function getTypes() {
    $result = array();
    foreach ($this->bibdb as $b) {
      $result[$b->getType()] = 1;
    }
    $result = array_keys($result);
    return $result;
  }

  /** Generates and returns an array consisting of all authors.
   * The returned array is a hash table with keys 
   * and values .
   */
  function authorIndex(){
    $result = array();
    foreach ($this->bibdb as $bib) {
      foreach($bib->getRawAuthors() as $a){
        //we use an array because several authors can have the same lastname
        @$result[getLastName($a)][$bib->formatAuthor($a)]++;
      }
    }
    ksort($result);

    // now authors are sorted by last name
    // we rebuild a new array for having good keys in author page
    $realresult = array();
    foreach($result as $x) {
        ksort($x);
        foreach($x as $v => $tmp) $realresult[$v] = $v;
    }

    return $realresult;
  }

  /** Generates and returns an array consisting of all tags.
   */
  function tagIndex(){
    $result = array();
    foreach ($this->bibdb as $bib) {
      if (!$bib->hasField("keywords")) continue;
      $tags =preg_split('/[,;]/', $bib->getField("keywords"));
      foreach($tags as $a){
        $ta = trim($a);
        $result[$ta] = $ta;
      }
    }
    asort($result);
    return $result;
  }

  /** Generates and returns an array consisting of all years.
   */
  function yearIndex(){
    $result = array();
    foreach ($this->bibdb as $bib) {
      if (!$bib->hasField("year")) continue;
      $year = $bib->getField("year");
      $result[$year] = $year;
      }
    arsort($result);
    return $result;
  }

  /** Given its ID, return the bib entry. */
  function getEntry($id){
    foreach($this->bibdb as $bib) {
      if($bib->getId() == $id)
 return $bib;
    }
    return null;
  }

  /** Given its key, return the bib entry. */
  function getEntryByKey($key) {
    return $this->bibdb[$key];
  }

  /**
   * Returns an array containing all bib entries matching the given
   * type.
   */
  function searchType($type){
    $result = array();
    foreach($this->bibdb as $bib) {
      if($bib->getType() == $type)
 $result[] = $bib;
    }
    return $result;
  }

  /** Returns an array of bib entries (BibEntry) that satisfy the query
   * $query is an hash with entry type as key and searched fragment as value
   * the returned array is sorted by year
   */
  function multisearch($query) {
    if (count($query)<1) {return array();}
    if (isset($query[Q_ALL])) return array_values($this->bibdb);

    $result = array();

    foreach ($this->bibdb as $bib) {
        $entryisselected = true;
        foreach ($query as $field => $fragment) {
          if ($field==Q_SEARCH) {
            // we search in the whole bib entry
            if (!$bib->hasPhrase($fragment)) {
              $entryisselected = false;
            }
          }
          else if ($field==Q_EXCLUDE) {
            if ($bib->hasPhrase($fragment)) {
              $entryisselected = false;
            }
          }
          else {
            if (!$bib->hasPhrase($fragment, $field))  {
              $entryisselected = false;
            }
          }

        }
        if ($entryisselected)  $result[$bib->getYear().$bib->getKey()] = $bib;
      }
      krsort($result);
      return $result;
  }
} // end class

/* returns the default embedded CSS of bibtexbrowser */
function bibtexbrowserDefaultCSS() {
?>

/* title */
.bibtitle { font-weight:bold; }
/* author */
.bibauthor { /* nothing by default */ }
/* booktitle (e.g. proceedings title, journal name, etc )*/
.bibbooktitle { font-style:italic; }
/* publisher */
.bibpublisher { /* nothing by default */ }


.title {
  color: #003366;
  font-size: large;
  font-weight: bold;
  text-align: right;
}

.header {
  background-color: #995124;
  color: #FFFFFF;
  padding: 1px 2px 1px 2px;
}

.rheader {
  font-weight: bold;
  background-color: #003366;
  color: #ffffff;
  padding: 2px;
  margin-bottom: 10px;
  border-bottom: #ff6633 2px solid;

}
.menu {
  font-size: x-small;
  background-color: #EFDDB4;
  padding: 0px;
  border: 1px solid #000000;
  margin: 0px;
}
.menu a {
  text-decoration: none;
  color: #003366;
}
.menu a:hover {
  color: #ff6633;
}

.bibref {
  padding:7px;
  padding-left:15px;
  vertical-align:text-top; 
}

.result {
  padding:0px;
  border: 1px solid #000000;
  margin:0px;
  background-color: #ffffff;
  width:100%;
}
.result a {
  text-decoration: none;
  color: #469AF8;
}

.result a:hover {
  color: #ff6633;
}

.purebibtex {
  font-family: monospace;
  background-color:#FFFFFF;
  font-size: small;
  border: 1px solid #000000;
  white-space:pre;
  
}
.input_box{
  margin-bottom : 2px;
}
.mini_se {
  border: none 0;
  border-top: 1px dashed #717171;
  height: 1px;
}
.a_name a {
  color:#469AF8;
  width:130px;
}

.rsslink {
  text-decoration: none;
  color:#F88017;
/* could be fancy, see : http://www.feedicons.com/ for icons*/
  /*background-image: url("rss.png"); text-indent: -9999px;*/
}
 and TITLE */
class HTMLWrapper {
/**
 * $content: an object with a display() method
 * $title: title of the page
 */
function HTMLWrapper(&$content,$metatags=array()/* an array name=>value*/) {

// when we load a page with AJAX
// the HTTP header is taken into account, not the 
header('Content-type: text/html; charset='.ENCODING);
echo ''."\n";

?>




getRSS()!='') echo ''; ?>
'."\n"; 
} // end foreach  



// now the title
echo ''; 
  
// now the CSS
echo '';

?>


display();?>


display();
  }
}

/** is used to create an subset of a bibtex file  */
class BibtexDisplay {

  /** an array of BibEbtry */
  var $results;

  /** the initial query to get the results */
  var $query;

  function BibtexDisplay(&$results, &$query) {
    $this->results=$results;
    $this->query=$query;
  }

  function display() {
    header('Content-type: text/plain; charset='.ENCODING);
    echo '% '.query2title($this->query)."\n";
    echo '% Encoding: '.ENCODING."\n";
    foreach($this->results as $bibentry) { echo $bibentry->getText()."\n"; }
    exit;
  }
}

/** is used to create an RSS feed */
class RSSDisplay {

  /** an array of BibEbtry */
  var $results;

  /** the initial query to get the results */
  var $query;

  function RSSDisplay(&$results, &$query) {
    $this->results=$results;
    $this->query=$query;
    $this->title = query2title($query);
  }

  /** tries to always output a valid XML/RSS string 
    * based on ENCODING, HTML tags, and the transformations 
    * that happened in latex2html */
  function text2rss($desc) {
    // first strip HTML tags 
    $desc = strip_tags($desc);
  
    // then decode characters encoded by latex2html
    $desc= html_entity_decode($desc);

    // some entities may still be here, we remove them
    // we replace html entities e.g. é by nothing
    // however XML entities are kept (e.g. 5)
    $desc = preg_replace('/&\w+;/','',$desc);
            
    // bullet proofing ampersand
    $desc = preg_replace('/&([^#])/','&$1',$desc);

    // be careful of < 
    $desc = str_replace('<','<',$desc);
    
    // final test with encoding:
    if (function_exists('mb_check_encoding')) { // (PHP 4 >= 4.4.3, PHP 5 >= 5.1.3)
      if (!mb_check_encoding($desc,ENCODING)) { 
        return 'encoding error: please check the content of ENCODING';
      }
    }
    
    return $desc;
  }
  
  
  function display() {
    header('Content-type: application/rss+xml');
    echo '';
//

?>

   
      
      http://
      
      
      bibtexbrowser v20110823

results as $bibentry) {
         ?>
         
         
         getURL());?>
         
          text2rss(bib2html($bibentry)."\n".$bibentry->getAbstract());
          ?>
          
         getKey());?>
         
         
   


wrapper='NoWrapper';

    // first pass, we will exit if we encounter key or menu or academic
    // other wise we just create the $this->query
    foreach($_GET as $keyword=>$value) {
      if (method_exists($this,$keyword)) {
        // if the return value is END_DISPATCH, we finish bibtexbrowser (but not the whole PHP process in case we are embedded)
        if ($this->$keyword()=='END_DISPATCH') return; 
      }
    }


    
    if (count($this->query)>0) {

       // first test for inconsistent queries
       if (isset($this->query[Q_ALL]) && count($this->query)>1) {
         // we discard the Q_ALL, it helps in embedded mode
         unset($this->query[Q_ALL]);
       }
    
       $this->selectedEntries = $_GET[Q_DB]->multisearch($this->query);

       // required for PHP4 to have this intermediate variable
       $x = new $this->displayer($this->selectedEntries,$this->query);
       new $this->wrapper($x);
    }
    else { 
       // we send a redirection for having the frameset
       // if some contents have already been sent, for instance if we are included
       // this means doing nothing
       if ( headers_sent() == false ) { /* to avoid sending an unnecessary frameset */ 
         header("Location: ".$_SERVER['SCRIPT_NAME']."?frameset&bib=".$_GET[Q_FILE]);
       }
     }
  }

  function all() {
    $this->query[Q_ALL]=1;
  }

  function rss() {
    $this->displayer='RSSDisplay';
    $this->wrapper='NoWrapper';
  }

  function astext() {
    $this->displayer='BibtexDisplay';
    $this->wrapper='NoWrapper';
  }

  function search() {
    if (preg_match('/utf-?8/i',ENCODING)) {
      $_GET[Q_SEARCH] = urldecode($_GET[Q_SEARCH]);
    }
    $this->query[Q_SEARCH]=$_GET[Q_SEARCH];
  }

  function exclude() { $this->query[Q_EXCLUDE]=$_GET[Q_EXCLUDE]; }

  function year() {  $this->query[Q_YEAR]=$_GET[Q_YEAR]; }

  function keywords() { $this->query[Q_TAG]=$_GET[Q_TAG]; }

  function author() {
    // Friday, October 29 2010
    // changed fomr 'author' to '_author'
    // because '_author' is already formatted
    // doing so we can search at the same time "Joe Dupont" an "Dupont, Joe"
    $this->query['_author']=$_GET[Q_AUTHOR];
  }

  function type() { 
    // remarks KEN
    // "book" selects inbook, book, bookchapter
    // so we add the regexp modifiers
    if (strlen($_GET[Q_TYPE])>0 && !preg_match('/^\^.*\$$/',$_GET[Q_TYPE])) { $_GET[Q_TYPE] = '^'.$_GET[Q_TYPE].'$'; }
    $this->query[Q_TYPE]= $_GET[Q_TYPE];
  }

  function menu() {
    $menu = new MenuManager($_GET[Q_DB]);
    new $this->wrapper($menu,array(array('robots','noindex')));
    return 'END_DISPATCH';
  }

  /** the academic keyword in URLs switch from a year based viey to a publication type based view */
  function academic() {
     $this->displayer='AcademicDisplay';
     
     
     // backward compatibility with old GET API
     // this is deprecated
     // instead of academic=Martin+Monperrus
     // you should use author=Martin+Monperrus&academic
     // be careful of the semantics of === and !==
     // 'foo bar' == true is true
     // 123 == true is true (and whatever number different from 0
     // 0 == true is true
     // '1'!=1 is **false**
     if(!isset($_GET[Q_AUTHOR]) && $_GET[Q_ACADEMIC]!==true && $_GET[Q_ACADEMIC]!=='true' && $_GET[Q_ACADEMIC]!=1 && $_GET[Q_ACADEMIC]!='') {
      $_GET[Q_AUTHOR]=$_GET[Q_ACADEMIC];
      $this->query[Q_AUTHOR]=$_GET[Q_ACADEMIC];
     }

  }

  function key() {
    if ($_GET[Q_DB]->contains($_GET[Q_KEY])) {
      $bibdisplay = new BibEntryDisplay($_GET[Q_DB]->getEntryByKey($_GET[Q_KEY]));
      new $this->wrapper($bibdisplay,$bibdisplay->metadata());
      return 'END_DISPATCH';
    }
    else { new  NonExistentBibEntryError(); }
  }

  /** is used to remotely analyzed a situation */
  function diagnosis() {
    header('Content-type: text/plain');
    echo "php version: ".phpversion()."\n";
    echo "bibtexbrowser version: 20110823\n";
    echo "dir: ".decoct(fileperms(dirname(__FILE__)))."\n";
    echo "bibtex file: ".decoct(fileperms($_GET[Q_FILE]))."\n";
    exit;
  }

  function frameset() {    ?>