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

   /**
   * 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;
  }
}


/**bibtexbrowser uses this function which encapsulates the user-defined name*/
function bib2html(&$bibentry) {
  $function = BIBLIOGRAPHYSTYLE;
  return $function($bibentry);
}


include('bibtexbrowser-style-default.php');





// ----------------------------------------------------------------------
// DISPLAY MANAGEMENT
// ----------------------------------------------------------------------


/**
 * Given an array of parameter, creates a query string
 */
function createQueryString($array_param) {
 // first we add the name of the bib file
 $array_param[Q_FILE] = urlencode($_GET[Q_FILE]);

 // then a simple transformation and implode
 foreach ($array_param as $key => $val) {
      $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));
}



/**
 * Returns the formated author name w.r.t to the user preference encoded in COMMA_NAMES
 */
function formatAuthor($author){
  if (COMMA_NAMES) {
    return formatAuthorCommaSeparated($author);
  }
  else return formatAuthorCanonical($author);
}

/**
 * Returns the formated author name as "FirstName LastName".
 */
function formatAuthorCanonical($author){
    list($firstname, $lastname) = splitFullName($author);
    if ($firstname!='') return $firstname.' '.$lastname;
    else return $lastname;
}

/**
 * Returns the formated author name as "LastName, FirstName".
 */
function formatAuthorCommaSeparated($author){
    list($firstname, $lastname) = splitFullName($author);
    if ($firstname!='') return $lastname.', '.$firstname;
    else return $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 '
';
  }
}


/**
 * A class providing GUI controllers in a frame.
 */
class MenuManager extends BibtexBrowserDisplay {

  /** The bibliographic database, an instance of class BibDataBase. */
  var $db;

  /** Creates a new display manager that uses the given bib database. */
  function MenuManager(&$db) {
    $this->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 .= '[pred]\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++;
    }
  }
}

/** Class to encapsulates the header formating and the powered bw 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";}


}

/** transforms an array representing a query into a formatted string */
function query2title(&$query) {
    $headers = array();
    foreach($query as $k=>$v) $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.'?'.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();

  }

  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();

    // Books
    $this->search2html(array(Q_TYPE=>'book'),'Books');

    // Journal / Bookchapters
    $this->search2html(array(Q_TYPE=>'article|incollection'),'Refereed Articles and Book Chapters');

    // conference papers
    $this->search2html(array(Q_TYPE=>'inproceedings',Q_EXCLUDE=>'workshop'),'Refereed Conference Papers');

    // workshop papers
    $this->search2html(array(Q_TYPE=>'inproceedings',Q_SEARCH=>'workshop'),'Refereed Workshop Papers');

    // misc and thesis
    $this->search2html(array(Q_TYPE=>'misc|phdthesis|mastersthesis|bachelorsthesis|techreport'),'Other Publications');

    echo $this->poweredby();
  }

}




/** 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() {
    echo $this->bib->toCoins();
    echo $this->formatedHeader();
    echo $this->bib->toEntryUnformatted();
    //echo $this->bib->getUrlLink();

    echo $this->poweredby();
  }

  /** Creates metadata for Google Scholar
   * + a description
   * See http://www.monperrus.net/martin/accurate+bibliographic+metadata+and+google+scholar
   * */
  function metadata() {
    $result=array();
    
    // 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());

    // citation_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->getType()=="inproceedings") {
       $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"));
    }

    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)][$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*/) {

echo ''."\n";

?>




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



// now the title
echo ''; 
  
// now the CSS
if (is_readable('bibtexbrowser.css')) {
  echo '';
}
else {
  // we use the embedded 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 v__MTIME__

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() {
    $this->query[Q_AUTHOR]=$_GET[Q_AUTHOR];
  }

  function 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
     if($_GET[Q_ACADEMIC]!==true && $_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: __MTIME__\n";
    echo "dir: ".decoct(fileperms(dirname(__FILE__)))."\n";
    echo "bibtex file: ".decoct(fileperms($_GET[Q_FILE]))."\n";
    exit;
  }

  function frameset() {    ?>