/******************************************************************************

 *

 * 

 *

 *

 * Permission to use, copy, modify, and distribute this software and its

 * documentation under the terms of the GNU General Public License is hereby 

 * granted. No representations are made about the suitability of this software 

 * for any purpose. It is provided "as is" without express or implied warranty.

 * See the GNU General Public License for more details.

 *

 * Documents produced by Doxygen are derivative works derived from the

 * input used in their production; they are not affected by this license.

 *

 */

/** @file

 *  @brief This file contains functions for the various index pages.

 */

#include <stdlib.h>

#include <qtextstream.h>

#include <qdatetime.h>

#include <qdir.h>

#include <qregexp.h>

#include "message.h"

#include "index.h"

#include "doxygen.h"

#include "config.h"

#include "filedef.h"

#include "outputlist.h"

#include "util.h"

#include "groupdef.h"

#include "language.h"

#include "htmlgen.h"

#include "htmlhelp.h"

#include "ftvhelp.h"

#include "dot.h"

#include "pagedef.h"

#include "dirdef.h"

#include "vhdldocgen.h"

#define MAX_ITEMS_BEFORE_MULTIPAGE_INDEX 200

#define MAX_ITEMS_BEFORE_QUICK_INDEX 30

static const char search_script[]=

#include "search_js.h"

;

int annotatedClasses;

int hierarchyClasses;

int documentedFiles;

int documentedGroups;

int documentedNamespaces;

int indexedPages;

int documentedClassMembers[CMHL_Total];

int documentedFileMembers[FMHL_Total];

int documentedNamespaceMembers[NMHL_Total];

int documentedHtmlFiles;

int documentedPages;

int documentedDirs;

int countClassHierarchy();

int countClassMembers(int filter=CMHL_All);

int countFileMembers(int filter=FMHL_All);

void countFiles(int &htmlFiles,int &files);

int countGroups();

int countDirs();

int countNamespaces();

int countAnnotatedClasses();

int countNamespaceMembers(int filter=NMHL_All);

int countIncludeFiles();

void countRelatedPages(int &docPages,int &indexPages);

void countDataStructures()

{

  annotatedClasses           = countAnnotatedClasses(); // "classes" + "annotated"

  hierarchyClasses           = countClassHierarchy();   // "hierarchy"

  countFiles(documentedHtmlFiles,documentedFiles);      // "files"

  countRelatedPages(documentedPages,indexedPages);      // "pages"

  documentedGroups           = countGroups();           // "modules"

  documentedNamespaces       = countNamespaces();       // "namespaces"

  documentedDirs             = countDirs();             // "dirs"

  // "globals"

  // "namespacemembers"

  // "functions"

}

static void startIndexHierarchy(OutputList &ol,int level)

{

  ol.pushGeneratorState();

  ol.disable(OutputGenerator::Man);

  ol.disable(OutputGenerator::Html);

  if (level<6) ol.startIndexList();

  ol.enableAll();

  ol.disable(OutputGenerator::Latex);

  ol.disable(OutputGenerator::RTF);

  ol.startItemList();

  ol.popGeneratorState();

}

static void endIndexHierarchy(OutputList &ol,int level)

{

  ol.pushGeneratorState();

  ol.disable(OutputGenerator::Man);

  ol.disable(OutputGenerator::Html);

  if (level<6) ol.endIndexList();

  ol.enableAll();

  ol.disable(OutputGenerator::Latex);

  ol.disable(OutputGenerator::RTF);

  ol.endItemList();

  ol.popGeneratorState();

}

//----------------------------------------------------------------------------

class MemberIndexList : public QList<MemberDef>

{

  public:

    MemberIndexList() : QList<MemberDef>() {}

    ~MemberIndexList() {}

    int compareItems(GCI item1, GCI item2)

    {

      MemberDef *md1=(MemberDef *)item1;

      MemberDef *md2=(MemberDef *)item2;

      return stricmp(md1->name(),md2->name());

    }

};

#define MEMBER_INDEX_ENTRIES 256

static MemberIndexList g_memberIndexLetterUsed[CMHL_Total][MEMBER_INDEX_ENTRIES];

static MemberIndexList g_fileIndexLetterUsed[FMHL_Total][MEMBER_INDEX_ENTRIES];

static MemberIndexList g_namespaceIndexLetterUsed[NMHL_Total][MEMBER_INDEX_ENTRIES];

static bool g_classIndexLetterUsed[CHL_Total][256];

const int maxItemsBeforeQuickIndex = MAX_ITEMS_BEFORE_QUICK_INDEX;

//----------------------------------------------------------------------------

// strips w from s iff s starts with w

bool stripWord(QCString &s,QCString w)

{

  bool success=FALSE;

  if (s.left(w.length())==w) 

  {

    success=TRUE;

    s=s.right(s.length()-w.length());

  }

  return success;

}

//----------------------------------------------------------------------------

// some quasi intelligent brief description abbreviator :^)

QCString abbreviate(const char *s,const char *name)

{

  QCString scopelessName=name;

  int i=scopelessName.findRev("::");

  if (i!=-1) scopelessName=scopelessName.mid(i+2);

  QCString result=s;

  result=result.stripWhiteSpace();

  // strip trailing .

  if (!result.isEmpty() && result.at(result.length()-1)=='.') 

    result=result.left(result.length()-1);

  // strip any predefined prefix

  QStrList &briefDescAbbrev = Config_getList("ABBREVIATE_BRIEF");

  const char *p = briefDescAbbrev.first();

  while (p)

  {

    QCString s = p;

    s.replace(QRegExp("\\$name"), scopelessName);  // replace $name with entity name

    s += " ";

    stripWord(result,s);

    p = briefDescAbbrev.next();

  }

  // capitalize first word

  if (!result.isEmpty())

  {

    int c=result[0];

    if (c>='a' && c<='z') c+='A'-'a';

    result[0]=c;

  }

  return result;

}

//----------------------------------------------------------------------------

{

  bool fancyTabs = TRUE;

  if (fancyTabs)

  {

  }

  else

  {

    ol.writeString("  <div class=\"qindex\">"); 

  }

}

static void endQuickIndexList(OutputList &ol)

{

  bool fancyTabs = TRUE;

  if (fancyTabs)

  {

    ol.writeString("    </ul>\n");

  }

  ol.writeString("  </div>\n");

}

static void startQuickIndexItem(OutputList &ol,const char *l,

                                bool hl,bool compact,bool &first)

{

  bool fancyTabs = TRUE;

  if (!first && compact && !fancyTabs) ol.writeString(" | ");

  first=FALSE;

  if (fancyTabs)

  {

    ol.writeString("      <li"); 

    if (hl) ol.writeString(" class=\"current\"");

    ol.writeString("><a ");

  }

  else

  {

    if (!compact) ol.writeString("<li>");

    if (hl && compact)

    {

      ol.writeString("<a class=\"qindexHL\" ");

    }

    else

    {

      ol.writeString("<a class=\"qindex\" ");

    }

  }

  ol.writeString("href=\""); 

  ol.writeString(l);

  ol.writeString("\">");

  if (fancyTabs)

  {

    ol.writeString("<span>");

  }

}

static void endQuickIndexItem(OutputList &ol)

{

  bool fancyTabs=TRUE;

  if (fancyTabs) ol.writeString("</span>");

  ol.writeString("</a>");

  if (fancyTabs) ol.writeString("</li>\n");

}

static QCString fixSpaces(const QCString &s)

{

  return substitute(s," "," ");

}

{

  ol.startTitleHead(fileName);

  ol.pushGeneratorState();

  ol.disable(OutputGenerator::Man);

}

void endTitle(OutputList &ol,const char *fileName,const char *name)

{

  ol.popGeneratorState();

  ol.endTitleHead(fileName,name);

}

void startFile(OutputList &ol,const char *name,const char *manName,

               const char *title,HighlightedItem hli,bool additionalIndices)

{

  ol.startFile(name,manName,title);

  if (!Config_getBool("DISABLE_INDEX")) 

  {

    ol.startQuickIndices();

    ol.writeQuickLinks(TRUE,hli);

    if (!additionalIndices)

    {

      ol.endQuickIndices();

    }

  }

  else

  {

    if (!additionalIndices)

    {

    }

  }

}

void endFile(OutputList &ol,bool)

{

  ol.endContents();

  ol.pushGeneratorState();

  ol.disableAllBut(OutputGenerator::Html);

  ol.writeFooter(); // write the footer

  ol.popGeneratorState();

  ol.endFile();

}

//----------------------------------------------------------------------------

static bool classHasVisibleChildren(ClassDef *cd)

{

  BaseClassListIterator bcli(*bcl);

  for ( ; bcli.current() ; ++bcli)

  {

    if (bcli.current()->classDef->isVisibleInHierarchy())

    {

      return TRUE;

    }

  }

  return FALSE;

}

void writeClassTree(OutputList &ol,BaseClassList *bcl,bool hideSuper,int level,FTVHelp* ftv)

{

  if (bcl==0) return;

  BaseClassListIterator bcli(*bcl);

  bool started=FALSE;

  for ( ; bcli.current() ; ++bcli)

  {

    ClassDef *cd=bcli.current()->classDef;

    {

      if (!started)

      {

        startIndexHierarchy(ol,level);

        Doxygen::indexList.incContentsDepth();

        if (ftv)

          ftv->incContentsDepth();

        started=TRUE;

      }

      ol.startIndexListItem();

      //printf("Passed...\n");

      bool hasChildren = !cd->visited && !hideSuper && classHasVisibleChildren(cd);

      //printf("tree4: Has children %s: %d\n",cd->name().data(),hasChildren);

      if (cd->isLinkable())

      {

        //printf("Writing class %s\n",cd->displayName().data());

        ol.startIndexItem(cd->getReference(),cd->getOutputFileBase());

        ol.parseText(cd->displayName());

        ol.endIndexItem(cd->getReference(),cd->getOutputFileBase());

        if (cd->isReference()) 

        { 

          ol.startTypewriter(); 

          ol.docify(" [external]");

          ol.endTypewriter();

        }

        Doxygen::indexList.addContentsItem(hasChildren,cd->displayName(),cd->getReference(),cd->getOutputFileBase(),0);

        if (ftv)

          ftv->addContentsItem(hasChildren,cd->displayName(),cd->getReference(),cd->getOutputFileBase(),0);

      }

      else

      {

        ol.startIndexItem(0,0);

        ol.parseText(cd->name());

        ol.endIndexItem(0,0);

        Doxygen::indexList.addContentsItem(hasChildren,cd->displayName(),0,0,0);

        if (ftv)

          ftv->addContentsItem(hasChildren,cd->displayName(),0,0,0);

      }

      if (hasChildren)

      {

        //printf("Class %s at %p visited=%d\n",cd->name().data(),cd,cd->visited);

        bool wasVisited=cd->visited;

        cd->visited=TRUE;

      }

      ol.endIndexListItem();

    }

  }

  if (started) 

  {

    endIndexHierarchy(ol,level);

    Doxygen::indexList.decContentsDepth();

    if (ftv)

      ftv->decContentsDepth();

  }

}

//----------------------------------------------------------------------------

/*! Generates HTML Help tree of classes */

void writeClassTree(BaseClassList *cl,int level)

{

  if (cl==0) return;

  BaseClassListIterator cli(*cl);

  bool started=FALSE;

  for ( ; cli.current() ; ++cli)

  {

    ClassDef *cd=cli.current()->classDef;

    if (cd->isVisibleInHierarchy() && hasVisibleRoot(cd->baseClasses()))

    //if (cd->isVisibleInHierarchy() && !cd->visited)

    {

      if (!started)

      {

        Doxygen::indexList.incContentsDepth();

        started=TRUE;

      }

      bool hasChildren = !cd->visited && classHasVisibleChildren(cd);

      //printf("tree2: Has children %s: %d\n",cd->name().data(),hasChildren);

      if (cd->isLinkable())

      {

        Doxygen::indexList.addContentsItem(hasChildren,cd->displayName(),cd->getReference(),cd->getOutputFileBase(),0);

      }

      if (hasChildren)

      {

        writeClassTree(cd->subClasses(),level+1);

      }

      cd->visited=TRUE;

    }

  }

  if (started) 

  {

    Doxygen::indexList.decContentsDepth();

  }

}

//----------------------------------------------------------------------------

/*! Generates HTML Help tree of classes */

void writeClassTreeNode(ClassDef *cd,bool &started,int level)

{

  //printf("writeClassTreeNode(%s) visited=%d\n",cd->name().data(),cd->visited);

  if (cd->isVisibleInHierarchy() && !cd->visited)

  {

    if (!started)

    {

      started=TRUE;

    }

    bool hasChildren = classHasVisibleChildren(cd);

    //printf("node: Has children %s: %d\n",cd->name().data(),hasChildren);

    if (cd->isLinkable())

    {

      Doxygen::indexList.addContentsItem(hasChildren,cd->displayName(),cd->getReference(),cd->getOutputFileBase(),0);

    }

    if (hasChildren)

    {

    }

    cd->visited=TRUE;

  }

}

void writeClassTree(ClassList *cl,int level)

{

  if (cl==0) return;

  ClassListIterator cli(*cl);

  bool started=FALSE;

  for ( cli.toFirst() ; cli.current() ; ++cli)

  {

    cli.current()->visited=FALSE;

  }

  for ( cli.toFirst() ; cli.current() ; ++cli)

  {

    writeClassTreeNode(cli.current(),started,level);