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

 *

 * 

 *

 * Copyright (C) 1997-2015 by Dimitri van Heesch.

 *

 * 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.

 *

 */

#include <ctype.h>

#include <qregexp.h>

#include "groupdef.h"

#include "classdef.h"

#include "filedef.h"

#include "classlist.h"

#include "outputlist.h"

#include "namespacedef.h"

#include "language.h"

#include "util.h"

#include "memberlist.h"

#include "message.h"

#include "membergroup.h"

#include "doxygen.h"

#include "pagedef.h"

#include "docparser.h"

#include "searchindex.h"

#include "dot.h"

#include "vhdldocgen.h"

#include "layout.h"

#include "arguments.h"

#include "entry.h"

#include "membername.h"

#include "dirdef.h"

#include "config.h"

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

GroupDef::GroupDef(const char *df,int dl,const char *na,const char *t,

                   const char *refFileName) : Definition(df,dl,1,na)

{

  fileList = new FileList;

  classSDict = new ClassSDict(17);

  groupList = new GroupList;

  namespaceSDict = new NamespaceSDict(17);

  pageDict = new PageSDict(17);

  exampleDict = new PageSDict(17);

  dirList = new DirList;

  allMemberNameInfoSDict = new MemberNameInfoSDict(17);

  allMemberNameInfoSDict->setAutoDelete(TRUE);

  if (refFileName)

  {

    fileName=stripExtension(refFileName);

  }

  else

  {

    fileName = convertNameToFile(QCString("group_")+na);

  }

  setGroupTitle( t );

  memberGroupSDict = new MemberGroupSDict;

  memberGroupSDict->setAutoDelete(TRUE);

  allMemberList = new MemberList(MemberListType_allMembersList);

  visited = 0;

  groupScope = 0;

  m_subGrouping=Config_getBool(SUBGROUPING);

}

GroupDef::~GroupDef()

{

  delete fileList;

  delete classSDict;

  delete groupList;

  delete namespaceSDict;

  delete pageDict;

  delete exampleDict;

  delete allMemberList;

  delete allMemberNameInfoSDict;

  delete memberGroupSDict;

  delete dirList;

}

void GroupDef::setGroupTitle( const char *t )

{

  if ( t && qstrlen(t) )

  {

    title = t;

    titleSet = TRUE;

  }

  else

  {

    title = name();

    title.at(0)=toupper(title.at(0));

    titleSet = FALSE;

  }

}

void GroupDef::distributeMemberGroupDocumentation()

{

  MemberGroupSDict::Iterator mgli(*memberGroupSDict);

  MemberGroup *mg;

  for (;(mg=mgli.current());++mgli)

  {

    mg->distributeMemberGroupDocumentation();

  }

}

void GroupDef::findSectionsInDocumentation()

{

  docFindSections(documentation(),this,0,docFile());

  MemberGroupSDict::Iterator mgli(*memberGroupSDict);

  MemberGroup *mg;

  for (;(mg=mgli.current());++mgli)

  {

    mg->findSectionsInDocumentation();

  }

  QListIterator<MemberList> mli(m_memberLists);

  MemberList *ml;

  for (mli.toFirst();(ml=mli.current());++mli)

  {

    if (ml->listType()&MemberListType_declarationLists)

    {

      ml->findSectionsInDocumentation();

    }

  }

}

void GroupDef::addFile(const FileDef *def)

{

  static bool sortBriefDocs = Config_getBool(SORT_BRIEF_DOCS);

  if (def->isHidden()) return;

  updateLanguage(def);

  if (sortBriefDocs)

    fileList->inSort(def);

  else

    fileList->append(def);

}

bool GroupDef::addClass(const ClassDef *cd)

{

  static bool sortBriefDocs = Config_getBool(SORT_BRIEF_DOCS);

  if (cd->isHidden()) return FALSE;

  updateLanguage(cd);

  QCString qn = cd->name();

  if (classSDict->find(qn)==0)

  {

    //printf("--- addClass %s sort=%d\n",qn.data(),sortBriefDocs);

    if (sortBriefDocs)

    {

      classSDict->inSort(qn,cd);

    }

    else

    {

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

      if (i==-1) i=qn.find('.');

      bool found=FALSE;

      //printf("i=%d\n",i);

      if (i!=-1)

      {

        // add nested classes (e.g. A::B, A::C) after their parent (A) in 

        // order of insertion

        QCString scope = qn.left(i);

        int j=classSDict->findAt(scope);

        if (j!=-1)

        {

          while (j<(int)classSDict->count() && 

              classSDict->at(j)->qualifiedName().left(i)==scope)

          {

            //printf("skipping over %s\n",classSDict->at(j)->qualifiedName().data());

            j++;

          }

          //printf("Found scope at index %d\n",j);

          classSDict->insertAt(j,qn,cd);

          found=TRUE;

        }

      }

      if (!found) // no insertion point found -> just append

      {

        classSDict->append(qn,cd);

      }

    }

    return TRUE;

  }

  return FALSE;

}

bool GroupDef::addNamespace(const NamespaceDef *def)

{

  static bool sortBriefDocs = Config_getBool(SORT_BRIEF_DOCS);

  if (def->isHidden()) return FALSE;

  updateLanguage(def);

  if (namespaceSDict->find(def->name())==0)

  {

    if (sortBriefDocs)

      namespaceSDict->inSort(def->name(),def);  

    else

      namespaceSDict->append(def->name(),def);

    return TRUE;

  }

  return FALSE;

}

void GroupDef::addDir(const DirDef *def)

{

  if (def->isHidden()) return;

  if (Config_getBool(SORT_BRIEF_DOCS))

    dirList->inSort(def);  

  else

    dirList->append(def);

}

void GroupDef::addPage(PageDef *def)

{

  if (def->isHidden()) return;

  //printf("Making page %s part of a group\n",def->name.data());

  pageDict->append(def->name(),def);

  def->makePartOfGroup(this);

}

void GroupDef::addExample(const PageDef *def)

{

  if (def->isHidden()) return;

  exampleDict->append(def->name(),def);

}

void GroupDef::addMembersToMemberGroup()

{

  QListIterator<MemberList> mli(m_memberLists);

  MemberList *ml;

  for (mli.toFirst();(ml=mli.current());++mli)

  {

    if (ml->listType()&MemberListType_declarationLists)

    {

      ::addMembersToMemberGroup(ml,&memberGroupSDict,this);

    }

  }

  //printf("GroupDef::addMembersToMemberGroup() memberGroupList=%d\n",memberGroupList->count());

  MemberGroupSDict::Iterator mgli(*memberGroupSDict);

  MemberGroup *mg;

  for (;(mg=mgli.current());++mgli)

  {

    mg->setInGroup(TRUE);

  }

}

bool GroupDef::insertMember(MemberDef *md,bool docOnly)

{

  if (md->isHidden()) return FALSE;

  updateLanguage(md);

  //printf("GroupDef(%s)::insertMember(%s)\n", title.data(), md->name().data());

  MemberNameInfo *mni=0;

  if ((mni=(*allMemberNameInfoSDict)[md->name()]))

  { // member with this name already found

    MemberNameInfoIterator srcMnii(*mni); 

    MemberInfo *srcMi;

    for ( ; (srcMi=srcMnii.current()) ; ++srcMnii )

    {

      MemberDef *srcMd = srcMi->memberDef;

      if (srcMd==md) return FALSE; // already added before!

      bool sameScope = srcMd->getOuterScope()==md->getOuterScope() || // same class or namespace

          // both inside a file => definition and declaration do not have to be in the same file

           (srcMd->getOuterScope()->definitionType()==Definition::TypeFile &&

               md->getOuterScope()->definitionType()==Definition::TypeFile); 

      ArgumentList *srcMdAl  = srcMd->argumentList();

      ArgumentList *mdAl     = md->argumentList();

      ArgumentList *tSrcMdAl = srcMd->templateArguments();

      ArgumentList *tMdAl    = md->templateArguments();

      if (srcMd->isFunction() && md->isFunction() && // both are a function

          ((tSrcMdAl==0 && tMdAl==0) || 

           (tSrcMdAl!=0 && tMdAl!=0 && tSrcMdAl->count()==tMdAl->count())

          ) &&       // same number of template arguments

          matchArguments2(srcMd->getOuterScope(),srcMd->getFileDef(),srcMdAl,

                          md->getOuterScope(),md->getFileDef(),mdAl,

                          TRUE

                         ) && // matching parameters

          sameScope // both are found in the same scope

         )

      {

        if (srcMd->getGroupAlias()==0) 

        {

          md->setGroupAlias(srcMd); 

        }

        else if (md!=srcMd->getGroupAlias())

        {

          md->setGroupAlias(srcMd->getGroupAlias()); 

        }

        return FALSE; // member is the same as one that is already added

      }

    }

    mni->append(new MemberInfo(md,md->protection(),md->virtualness(),FALSE));

  }

  else

  {

    mni = new MemberNameInfo(md->name());

    mni->append(new MemberInfo(md,md->protection(),md->virtualness(),FALSE));

    allMemberNameInfoSDict->append(mni->memberName(),mni);

  }

  //printf("Added member!\n");

  allMemberList->append(md); 

  switch(md->memberType())

  {

    case MemberType_Variable:     

      if (!docOnly)

      {

        addMemberToList(MemberListType_decVarMembers,md);

      }

      addMemberToList(MemberListType_docVarMembers,md);

      break;

    case MemberType_Function: 

      if (!docOnly)

      {

        addMemberToList(MemberListType_decFuncMembers,md);

      }

      addMemberToList(MemberListType_docFuncMembers,md);

      break;

    case MemberType_Typedef:      

      if (!docOnly)

      {

        addMemberToList(MemberListType_decTypedefMembers,md);

      }

      addMemberToList(MemberListType_docTypedefMembers,md);

      break;

    case MemberType_Enumeration:  

      if (!docOnly)

      {

        addMemberToList(MemberListType_decEnumMembers,md);

      }

      addMemberToList(MemberListType_docEnumMembers,md);

      break;

    case MemberType_EnumValue:    

      if (!docOnly)

      {

        addMemberToList(MemberListType_decEnumValMembers,md);

      }

      addMemberToList(MemberListType_docEnumValMembers,md);

      break;

    case MemberType_Define:       

      if (!docOnly)

      {

        addMemberToList(MemberListType_decDefineMembers,md);

      }

      addMemberToList(MemberListType_docDefineMembers,md);

      break;

    case MemberType_Signal:       

      if (!docOnly)

      {

        addMemberToList(MemberListType_decSignalMembers,md);

      }

      addMemberToList(MemberListType_docSignalMembers,md);

      break;

    case MemberType_Slot:       

      if (md->protection()==Public)

      {

        if (!docOnly)

        {

          addMemberToList(MemberListType_decPubSlotMembers,md);

        }

        addMemberToList(MemberListType_docPubSlotMembers,md);

      }

      else if (md->protection()==Protected)

      {

        if (!docOnly)

        {

          addMemberToList(MemberListType_decProSlotMembers,md);

        }

        addMemberToList(MemberListType_docProSlotMembers,md);

      }

      else

      {

        if (!docOnly)

        {

          addMemberToList(MemberListType_decPriSlotMembers,md);

        }

        addMemberToList(MemberListType_docPriSlotMembers,md);

      }

      break;

    case MemberType_Event:       

      if (!docOnly)

      {

        addMemberToList(MemberListType_decEventMembers,md);

      }

      addMemberToList(MemberListType_docEventMembers,md);

      break;

    case MemberType_Property:       

      if (!docOnly)

      {

        addMemberToList(MemberListType_decPropMembers,md);

      }

      addMemberToList(MemberListType_docPropMembers,md);

      break;

    case MemberType_Friend:       

      if (!docOnly)

      {

        addMemberToList(MemberListType_decFriendMembers,md);

      }

      addMemberToList(MemberListType_docFriendMembers,md);

      break;

    default:

      err("GroupDef::insertMembers(): "

           "member `%s' (typeid=%d) with scope `%s' inserted in group scope `%s'!\n",

           md->name().data(),md->memberType(),

           md->getClassDef() ? md->getClassDef()->name().data() : "",

           name().data());

  }

  return TRUE;

}

void GroupDef::removeMember(MemberDef *md)

{

  // fprintf(stderr, "GroupDef(%s)::removeMember( %s )\n", title.data(), md->name().data());

  MemberNameInfo *mni = allMemberNameInfoSDict->find(md->name());

  if (mni)

  {

    MemberNameInfoIterator mnii(*mni);

    while( mnii.current() )

    {

      if( mnii.current()->memberDef == md )

      {

	mni->remove(mnii.current());

        break;

      }

      ++mnii;

    }

    if( mni->isEmpty() )

    {

      allMemberNameInfoSDict->remove(md->name());

    }

    removeMemberFromList(MemberListType_allMembersList,md);

    switch(md->memberType())

    {

      case MemberType_Variable:

	removeMemberFromList(MemberListType_decVarMembers,md);

        removeMemberFromList(MemberListType_docVarMembers,md);

        break;

      case MemberType_Function: 

        removeMemberFromList(MemberListType_decFuncMembers,md);

        removeMemberFromList(MemberListType_docFuncMembers,md);

        break;

      case MemberType_Typedef:      

        removeMemberFromList(MemberListType_decTypedefMembers,md);

        removeMemberFromList(MemberListType_docTypedefMembers,md);

        break;

      case MemberType_Enumeration:  

        removeMemberFromList(MemberListType_decEnumMembers,md);

        removeMemberFromList(MemberListType_docEnumMembers,md);

        break;

      case MemberType_EnumValue:    

        removeMemberFromList(MemberListType_decEnumValMembers,md);

        removeMemberFromList(MemberListType_docEnumValMembers,md);

        break;

      case MemberType_Define:       

        removeMemberFromList(MemberListType_decDefineMembers,md);

        removeMemberFromList(MemberListType_docDefineMembers,md);

        break;

      case MemberType_Signal:       

        removeMemberFromList(MemberListType_decSignalMembers,md);

        removeMemberFromList(MemberListType_docSignalMembers,md);

        break;

      case MemberType_Slot:       

        if (md->protection()==Public)

        {

          removeMemberFromList(MemberListType_decPubSlotMembers,md);

          removeMemberFromList(MemberListType_docPubSlotMembers,md);

        }

        else if (md->protection()==Protected)

        {

          removeMemberFromList(MemberListType_decProSlotMembers,md);

          removeMemberFromList(MemberListType_docProSlotMembers,md);

        }

        else

        {

          removeMemberFromList(MemberListType_decPriSlotMembers,md);

          removeMemberFromList(MemberListType_docPriSlotMembers,md);

        }

        break;

      case MemberType_Event:       

        removeMemberFromList(MemberListType_decEventMembers,md);

        removeMemberFromList(MemberListType_docEventMembers,md);

        break;

      case MemberType_Property:       

        removeMemberFromList(MemberListType_decPropMembers,md);

        removeMemberFromList(MemberListType_docPropMembers,md);

        break;

      case MemberType_Friend:       

        removeMemberFromList(MemberListType_decFriendMembers,md);

        removeMemberFromList(MemberListType_docFriendMembers,md);

        break;

      default:

        err("GroupDef::removeMember(): unexpected member remove in file!\n");

    }

  }

}

bool GroupDef::findGroup(const GroupDef *def) const

{

  if (this==def)

  {

    return TRUE;

  }

  else if (groupList)

  {

    GroupListIterator it(*groupList);

    GroupDef *gd;

    for (;(gd=it.current());++it)

    {

      if (gd->findGroup(def))

      {

        return TRUE;

      }

    }

  }

  return FALSE;

}

void GroupDef::addGroup(const GroupDef *def)

{

  //printf("adding group `%s' to group `%s'\n",def->name().data(),name().data());

  //if (Config_getBool(SORT_MEMBER_DOCS))

  //  groupList->inSort(def);

  //else

  groupList->append(def);

}

bool GroupDef::isASubGroup() const

{

  GroupList *groups = partOfGroups();

  return groups!=0 && groups->count()!=0;

}

int GroupDef::countMembers() const

{

  return fileList->count()+

         classSDict->count()+

         namespaceSDict->count()+

         groupList->count()+

         allMemberList->count()+

         pageDict->count()+

         exampleDict->count();

}

/*! Compute the HTML anchor names for all members in the group */ 

void GroupDef::computeAnchors()

{

  //printf("GroupDef::computeAnchors()\n");

  setAnchors(allMemberList);

}

void GroupDef::writeTagFile(FTextStream &tagFile)

{

  tagFile << "  <compound kind=\"group\">" << endl;

  tagFile << "    <name>" << convertToXML(name()) << "</name>" << endl;

  tagFile << "    <title>" << convertToXML(title) << "</title>" << endl;

  tagFile << "    <filename>" << convertToXML(getOutputFileBase()) << Doxygen::htmlFileExtension << "</filename>" << endl;

  QListIterator<LayoutDocEntry> eli(

      LayoutDocManager::instance().docEntries(LayoutDocManager::Group));

  LayoutDocEntry *lde;

  for (eli.toFirst();(lde=eli.current());++eli)

  {

    switch (lde->kind())

    {

      case LayoutDocEntry::GroupClasses:

        {

          if (classSDict)

          {

            SDict<ClassDef>::Iterator ci(*classSDict);

            ClassDef *cd;

            for (ci.toFirst();(cd=ci.current());++ci)

            {

              if (cd->isLinkableInProject())

              {

                tagFile << "    <class kind=\"" << cd->compoundTypeString()

                        << "\">" << convertToXML(cd->name()) << "</class>" << endl;

              }

            }

          }

        }

        break;

      case LayoutDocEntry::GroupNamespaces:

        {

          if (namespaceSDict)

          {

            SDict<NamespaceDef>::Iterator ni(*namespaceSDict);

            NamespaceDef *nd;

            for (ni.toFirst();(nd=ni.current());++ni)

            {

              if (nd->isLinkableInProject())

              {

                tagFile << "    <namespace>" << convertToXML(nd->name())

                        << "</namespace>" << endl;

              }

            }

          }

        }

        break;

      case LayoutDocEntry::GroupFiles:

        {

          if (fileList)

          {

            QListIterator<FileDef> it(*fileList);

            FileDef *fd;

            for (;(fd=it.current());++it)

            {

              if (fd->isLinkableInProject())

              {

                tagFile << "    <file>" << convertToXML(fd->name()) << "</file>" << endl;

              }

            }

          }

        }

        break;

      case LayoutDocEntry::GroupPageDocs:

        {

          if (pageDict)

          {

            PageSDict::Iterator pdi(*pageDict);

            PageDef *pd=0;

            for (pdi.toFirst();(pd=pdi.current());++pdi)

            {

              QCString pageName = pd->getOutputFileBase();

              if (pd->isLinkableInProject())

              {

                tagFile << "    <page>" << convertToXML(pageName) << "</page>" << endl;

              }

            }

          }

        }

        break;

      case LayoutDocEntry::GroupDirs:

        {

          if (dirList)

          {

            QListIterator<DirDef> it(*dirList);

            DirDef *dd;

            for (;(dd=it.current());++it)

            {

              if (dd->isLinkableInProject())

              {

                tagFile << "    <dir>" << convertToXML(dd->displayName()) << "</dir>" << endl;

              }

            }

          }

        }

        break;

      case LayoutDocEntry::GroupNestedGroups:

        {

          if (groupList)

          {

            QListIterator<GroupDef> it(*groupList);

            GroupDef *gd;

            for (;(gd=it.current());++it)

            {

              if (gd->isVisible())

              {

                tagFile << "    <subgroup>" << convertToXML(gd->name()) << "</subgroup>" << endl;

              }

            }

          }

        }

        break;

      case LayoutDocEntry::MemberDecl:

        {

          LayoutDocEntryMemberDecl *lmd = (LayoutDocEntryMemberDecl*)lde;

          MemberList * ml = getMemberList(lmd->type);

          if (ml)

          {

            ml->writeTagFile(tagFile);

          }

        }

        break;

      case LayoutDocEntry::MemberGroups:

        {

          if (memberGroupSDict)

          {

            MemberGroupSDict::Iterator mgli(*memberGroupSDict);

            MemberGroup *mg;

            for (;(mg=mgli.current());++mgli)

            {

              mg->writeTagFile(tagFile);

            }

          }

        }

        break;

      default:

        break;

    }

  }

  writeDocAnchorsToTagFile(tagFile);

  tagFile << "  </compound>" << endl;

}

void GroupDef::writeDetailedDescription(OutputList &ol,const QCString &title)

{

  if ((!briefDescription().isEmpty() && Config_getBool(REPEAT_BRIEF)) 

      || !documentation().isEmpty() || !inbodyDocumentation().isEmpty()

     )

  {

    ol.pushGeneratorState();

    if (pageDict->count()!=countMembers()) // not only pages -> classical layout

    {

      ol.pushGeneratorState();

        ol.disable(OutputGenerator::Html);

        ol.writeRuler();

      ol.popGeneratorState();

      ol.pushGeneratorState();

        ol.disableAllBut(OutputGenerator::Html);

        ol.writeAnchor(0,"details");

      ol.popGeneratorState();

    }

    else

    {

      ol.disableAllBut(OutputGenerator::Man); // always print title for man page

    }

    ol.startGroupHeader();

    ol.parseText(title);

    ol.endGroupHeader();

    ol.popGeneratorState();

    // repeat brief description

    if (!briefDescription().isEmpty() && Config_getBool(REPEAT_BRIEF))

    {

      ol.generateDoc(briefFile(),briefLine(),this,0,briefDescription(),FALSE,FALSE);

    }

    // write separator between brief and details

    if (!briefDescription().isEmpty() && Config_getBool(REPEAT_BRIEF) &&

        !documentation().isEmpty())

    {

      ol.pushGeneratorState();

      ol.disable(OutputGenerator::Man);

      ol.disable(OutputGenerator::RTF);

      // ol.newParagraph(); // FIXME:PARA

      ol.enableAll();

      ol.disableAllBut(OutputGenerator::Man);

      ol.enable(OutputGenerator::Latex);

      ol.writeString("\n\n");

      ol.popGeneratorState();

    }

    // write detailed documentation

    if (!documentation().isEmpty())

    {

      ol.generateDoc(docFile(),docLine(),this,0,documentation()+"\n",TRUE,FALSE);

    }

    // write inbody documentation

    if (!inbodyDocumentation().isEmpty())

    {

      ol.generateDoc(inbodyFile(),inbodyLine(),this,0,inbodyDocumentation()+"\n",TRUE,FALSE);

    }

  }

}

void GroupDef::writeBriefDescription(OutputList &ol)

{

  if (hasBriefDescription())

  {

    DocRoot *rootNode = validatingParseDoc(briefFile(),briefLine(),this,0,

                                briefDescription(),TRUE,FALSE,0,TRUE,FALSE);

    if (rootNode && !rootNode->isEmpty())

    {

      ol.startParagraph();

      ol.pushGeneratorState();

      ol.disableAllBut(OutputGenerator::Man);

      ol.writeString(" - ");

      ol.popGeneratorState();

      ol.writeDoc(rootNode,this,0);

      ol.pushGeneratorState();

      ol.disable(OutputGenerator::RTF);

      ol.writeString(" \n");

      ol.enable(OutputGenerator::RTF);

      if (Config_getBool(REPEAT_BRIEF) ||

          !documentation().isEmpty()

         )

      {

        ol.disableAllBut(OutputGenerator::Html);

        ol.startTextLink(0,"details");

        ol.parseText(theTranslator->trMore());

        ol.endTextLink();

      }

      ol.popGeneratorState();

      ol.endParagraph();

    }

    delete rootNode;

  }

  ol.writeSynopsis();

}

void GroupDef::writeGroupGraph(OutputList &ol)

{

  if (Config_getBool(HAVE_DOT) /*&& Config_getBool(GROUP_GRAPHS)*/ )

  {

    DotGroupCollaboration graph(this);

    if (!graph.isTrivial())

    {

      msg("Generating dependency graph for group %s\n",qualifiedName().data());

      ol.pushGeneratorState();

      ol.disable(OutputGenerator::Man);

      //ol.startParagraph();

      ol.startGroupCollaboration();

      ol.parseText(theTranslator->trCollaborationDiagram(title));

      ol.endGroupCollaboration(graph);

      //ol.endParagraph();

      ol.popGeneratorState();

    }

  }

}

void GroupDef::writeFiles(OutputList &ol,const QCString &title)

{

  // write list of files

  if (fileList->count()>0)

  {

    ol.startMemberHeader("files");

    ol.parseText(title);

    ol.endMemberHeader();

    ol.startMemberList();

    QListIterator<FileDef> it(*fileList);

    FileDef *fd;

    for (;(fd=it.current());++it)

    {

      if (!fd->hasDocumentation()) continue;

      ol.startMemberDeclaration();

      ol.startMemberItem(fd->getOutputFileBase(),0);

      ol.docify(theTranslator->trFile(FALSE,TRUE)+" ");

      ol.insertMemberAlign();

      ol.writeObjectLink(fd->getReference(),fd->getOutputFileBase(),0,fd->name());

      ol.endMemberItem();

      if (!fd->briefDescription().isEmpty() && Config_getBool(BRIEF_MEMBER_DESC))

      {

        ol.startMemberDescription(fd->getOutputFileBase());

        ol.generateDoc(briefFile(),briefLine(),fd,0,fd->briefDescription(),FALSE,FALSE,0,TRUE,FALSE);

        ol.endMemberDescription();

      }

      ol.endMemberDeclaration(0,0);

    }

    ol.endMemberList();

  }

}

void GroupDef::writeNamespaces(OutputList &ol,const QCString &title)

{

  // write list of namespaces

  namespaceSDict->writeDeclaration(ol,title);

}

void GroupDef::writeNestedGroups(OutputList &ol,const QCString &title)

{

  // write list of groups

  int count=0;

  if (groupList->count()>0)

  {

    QListIterator<GroupDef> it(*groupList);

    GroupDef *gd;

    for (;(gd=it.current());++it)

    {

      if (gd->isVisible()) count++;

    }

  }

  if (count>0)

  {

    ol.startMemberHeader("groups");

    ol.parseText(title);

    ol.endMemberHeader();