#include <dot.h>

Public Member Functions
	DotClassGraph (ClassDef *cd, DotNode::GraphType t)

	~DotClassGraph ()

bool	isTrivial () const

bool	isTooBig () const

QCString	writeGraph (FTextStream &t, GraphOutputFormat gf, EmbeddedOutputFormat ef, const char path, const char fileName, const char *relPath, bool TBRank=TRUE, bool imageMap=TRUE, int graphId=-1) const

void	writeXML (FTextStream &t)

void	writeDocbook (FTextStream &t)

void	writeDEF (FTextStream &t)

QCString	diskName () const

Private Member Functions
void	buildGraph (ClassDef cd, DotNode n, bool base, int distance)

bool	determineVisibleNodes (DotNode *rootNode, int maxNodes, bool includeParents)

void	determineTruncatedNodes (QList< DotNode > &queue, bool includeParents)

void	addClass (ClassDef cd, DotNode n, int prot, const char label, const char usedName, const char *templSpec, bool base, int distance)

Private Attributes
DotNode *	m_startNode

QDict< DotNode > *	m_usedNodes

DotNode::GraphType	m_graphType

QCString	m_diskName

bool	m_lrRank

Static Private Attributes
static int	m_curNodeNumber = 0

Detailed Description

Representation of a class inheritance or dependency graph

Definition at line 168 of file dot.h.

Constructor & Destructor Documentation

DotClassGraph::DotClassGraph	(	ClassDef *	cd,
		DotNode::GraphType	t
	)

Definition at line 2939 of file dot.cpp.

 {
   //printf("--------------- DotClassGraph::DotClassGraph `%s'\n",cd->displayName().data());
   m_graphType = t;
   QCString tmp_url="";
   if (cd->isLinkable() && !cd->isHidden()) 
   {
     tmp_url=cd->getReference()+"$"+cd->getOutputFileBase();
     if (!cd->anchor().isEmpty())
     {
       tmp_url+="#"+cd->anchor();
     }
   }
   QCString className = cd->displayName();
   QCString tooltip = cd->briefDescriptionAsTooltip();
   m_startNode = new DotNode(m_curNodeNumber++,
                             className,
                             tooltip,
                             tmp_url.data(),
                             TRUE,                      // is a root node
                             cd
                            );
   m_startNode->setDistance(0);
   m_usedNodes = new QDict<DotNode>(1009);
   m_usedNodes->insert(className,m_startNode);
 
   //printf("Root node %s\n",cd->name().data());
   //if (m_recDepth>0) 
   //{
     buildGraph(cd,m_startNode,TRUE,1);
     if (t==DotNode::Inheritance) buildGraph(cd,m_startNode,FALSE,1);
   //}
 
   static int maxNodes = Config_getInt("DOT_GRAPH_MAX_NODES");
   //int directChildNodes = 1;
   //if (m_startNode->m_children!=0) 
   //  directChildNodes+=m_startNode->m_children->count();
   //if (t==DotNode::Inheritance && m_startNode->m_parents!=0)
   //  directChildNodes+=m_startNode->m_parents->count();
   //if (directChildNodes>maxNodes) maxNodes=directChildNodes;
   //openNodeQueue.append(m_startNode);
   m_lrRank = determineVisibleNodes(m_startNode,maxNodes,t==DotNode::Inheritance);
   QList<DotNode> openNodeQueue;
   openNodeQueue.append(m_startNode);
   determineTruncatedNodes(openNodeQueue,t==DotNode::Inheritance);
 
   m_diskName = cd->getFileBase().copy();
 }

DotClassGraph::~DotClassGraph ( )

Definition at line 3009 of file dot.cpp.

 {
   deleteNodes(m_startNode);
   delete m_usedNodes;
 }

Member Function Documentation

void DotClassGraph::addClass	(	ClassDef *	cd,
		DotNode *	n,
		int	prot,
		const char *	label,
		const char *	usedName,
		const char *	templSpec,
		bool	base,
		int	distance
	)

private

Definition at line 2590 of file dot.cpp.

 {
   if (Config_getBool("HIDE_UNDOC_CLASSES") && !cd->isLinkable()) return;
 
   int edgeStyle = (label || prot==EdgeInfo::Orange || prot==EdgeInfo::Orange2) ? EdgeInfo::Dashed : EdgeInfo::Solid;
   QCString className;
   if (cd->isAnonymous())
   {
     className="anonymous:";
     className+=label;
   }
   else if (usedName) // name is a typedef
   {
     className=usedName;
   }
   else if (templSpec) // name has a template part
   {
     className=insertTemplateSpecifierInScope(cd->name(),templSpec);
   }
   else // just a normal name
   {
     className=cd->displayName();
   }
   //printf("DotClassGraph::addClass(class=`%s',parent=%s,prot=%d,label=%s,dist=%d,usedName=%s,templSpec=%s,base=%d)\n",
   //                                 className.data(),n->m_label.data(),prot,label,distance,usedName,templSpec,base);
   DotNode *bn = m_usedNodes->find(className);
   if (bn) // class already inserted
   {
     if (base)
     {
       n->addChild(bn,prot,edgeStyle,label);
       bn->addParent(n);
     }
     else
     {
       bn->addChild(n,prot,edgeStyle,label);
       n->addParent(bn);
     }
     bn->setDistance(distance);
     //printf(" add exiting node %s of %s\n",bn->m_label.data(),n->m_label.data());
   }
   else // new class
   {
     QCString displayName=className;
     if (Config_getBool("HIDE_SCOPE_NAMES")) displayName=stripScope(displayName);
     QCString tmp_url;
     if (cd->isLinkable() && !cd->isHidden()) 
     {
       tmp_url=cd->getReference()+"$"+cd->getOutputFileBase();
       if (!cd->anchor().isEmpty())
       {
         tmp_url+="#"+cd->anchor();
       }
     }
     QCString tooltip = cd->briefDescriptionAsTooltip();
     bn = new DotNode(m_curNodeNumber++,
         displayName,
         tooltip,
         tmp_url.data(),
         FALSE,        // rootNode
         cd
        );
     if (base)
     {
       n->addChild(bn,prot,edgeStyle,label);
       bn->addParent(n);
     }
     else
     {
       bn->addChild(n,prot,edgeStyle,label);
       n->addParent(bn);
     }
     bn->setDistance(distance);
     m_usedNodes->insert(className,bn);
     //printf(" add new child node `%s' to %s hidden=%d url=%s\n",
     //    className.data(),n->m_label.data(),cd->isHidden(),tmp_url.data());
     
     buildGraph(cd,bn,base,distance+1);
   }
 }

void DotClassGraph::buildGraph	(	ClassDef *	cd,
		DotNode *	n,
		bool	base,
		int	distance
	)

private

Definition at line 2804 of file dot.cpp.

 {
   static bool templateRelations = Config_getBool("TEMPLATE_RELATIONS");
   //printf("DocClassGraph::buildGraph(%s,distance=%d,base=%d)\n",
   //    cd->name().data(),distance,base);
   // ---- Add inheritance relations
 
   if (m_graphType == DotNode::Inheritance || m_graphType==DotNode::Collaboration)
   {
     BaseClassList *bcl = base ? cd->baseClasses() : cd->subClasses();
     if (bcl)
     {
       BaseClassListIterator bcli(*bcl);
       BaseClassDef *bcd;
       for ( ; (bcd=bcli.current()) ; ++bcli )
       {
         //printf("-------- inheritance relation %s->%s templ=`%s'\n",
         //            cd->name().data(),bcd->classDef->name().data(),bcd->templSpecifiers.data());
         addClass(bcd->classDef,n,bcd->prot,0,bcd->usedName,
             bcd->templSpecifiers,base,distance); 
       }
     }
   }
   if (m_graphType == DotNode::Collaboration)
   {
     // ---- Add usage relations
 
     UsesClassDict *dict =
       base ? cd->usedImplementationClasses() :
              cd->usedByImplementationClasses()
       ;
     if (dict)
     {
       UsesClassDictIterator ucdi(*dict);
       UsesClassDef *ucd;
       for (;(ucd=ucdi.current());++ucdi)
       {
         QCString label;
         QDictIterator<void> dvi(*ucd->accessors);
         const char *s;
         bool first=TRUE;
         int count=0;
         int maxLabels=10;
         for (;(s=dvi.currentKey()) && count<maxLabels;++dvi,++count)
         {
           if (first) 
           {
             label=s;
             first=FALSE;
           }
           else
           {
             label+=QCString("\n")+s;
           }
         }
         if (count==maxLabels) label+="\n...";
         //printf("addClass: %s templSpec=%s\n",ucd->classDef->name().data(),ucd->templSpecifiers.data());
         addClass(ucd->classDef,n,EdgeInfo::Purple,label,0,
             ucd->templSpecifiers,base,distance);
       }
     }
   }
   if (templateRelations && base)
   {
     ConstraintClassDict *dict = cd->templateTypeConstraints();
     if (dict)
     {
       ConstraintClassDictIterator ccdi(*dict);
       ConstraintClassDef *ccd;
       for (;(ccd=ccdi.current());++ccdi)
       {
         QCString label;
         QDictIterator<void> dvi(*ccd->accessors);
         const char *s;
         bool first=TRUE;
         int count=0;
         int maxLabels=10;
         for (;(s=dvi.currentKey()) && count<maxLabels;++dvi,++count)
         {
           if (first)
           {
             label=s;
             first=FALSE;
           }
           else
           {
             label+=QCString("\n")+s;
           }
         }
         if (count==maxLabels) label+="\n...";
         //printf("addClass: %s templSpec=%s\n",ucd->classDef->name().data(),ucd->templSpecifiers.data());
         addClass(ccd->classDef,n,EdgeInfo::Orange2,label,0,
             0,TRUE,distance);
       }
     }
   }
 
   // ---- Add template instantiation relations
 
   if (templateRelations)
   {
     if (base) // template relations for base classes
     {
       ClassDef *templMaster=cd->templateMaster();
       if (templMaster)
       {
         QDictIterator<ClassDef> cli(*templMaster->getTemplateInstances());
         ClassDef *templInstance;
         for (;(templInstance=cli.current());++cli)
         {
           if (templInstance==cd)
           {
             addClass(templMaster,n,EdgeInfo::Orange,cli.currentKey(),0,
                 0,TRUE,distance);
           }
         }
       }
     }
     else // template relations for super classes
     {
       QDict<ClassDef> *templInstances = cd->getTemplateInstances();
       if (templInstances)
       {
         QDictIterator<ClassDef> cli(*templInstances);
         ClassDef *templInstance;
         for (;(templInstance=cli.current());++cli)
         {
           addClass(templInstance,n,EdgeInfo::Orange,cli.currentKey(),0,
               0,FALSE,distance);
         }
       }
     }
   }
 }

void DotClassGraph::determineTruncatedNodes	(	QList< DotNode > &	queue,
		bool	includeParents
	)

private

Definition at line 2672 of file dot.cpp.

 {
   while (queue.count()>0)
   {
     DotNode *n = queue.take(0);
     if (n->isVisible() && n->isTruncated()==DotNode::Unknown)
     {
       bool truncated = FALSE;
       if (n->m_children)
       {
         QListIterator<DotNode> li(*n->m_children);
         DotNode *dn;
         for (li.toFirst();(dn=li.current());++li)
         {
           if (!dn->isVisible()) 
             truncated = TRUE;
           else 
             queue.append(dn);
         }
       }
       if (n->m_parents && includeParents)
       {
         QListIterator<DotNode> li(*n->m_parents);
         DotNode *dn;
         for (li.toFirst();(dn=li.current());++li)
         {
           if (!dn->isVisible()) 
             truncated = TRUE;
           else 
             queue.append(dn);
         }
       }
       n->markAsTruncated(truncated);
     }
   }
 }

bool DotClassGraph::determineVisibleNodes	(	DotNode *	rootNode,
		int	maxNodes,
		bool	includeParents
	)

private

Definition at line 2709 of file dot.cpp.

 {
   QList<DotNode> childQueue;
   QList<DotNode> parentQueue;
   QArray<int> childTreeWidth;
   QArray<int> parentTreeWidth;
   childQueue.append(rootNode);
   if (includeParents) parentQueue.append(rootNode);
   bool firstNode=TRUE; // flag to force reprocessing rootNode in the parent loop 
                        // despite being marked visible in the child loop
   while ((childQueue.count()>0 || parentQueue.count()>0) && maxNodes>0)
   {
     static int maxDistance = Config_getInt("MAX_DOT_GRAPH_DEPTH");
     if (childQueue.count()>0)
     {
       DotNode *n = childQueue.take(0);
       int distance = n->distance();
       if (!n->isVisible() && distance<=maxDistance) // not yet processed
       {
         if (distance>0)
         {
           int oldSize=(int)childTreeWidth.size();
           if (distance>oldSize)
           {
             childTreeWidth.resize(QMAX(childTreeWidth.size(),(uint)distance));
             int i; for (i=oldSize;i<distance;i++) childTreeWidth[i]=0;
           }
           childTreeWidth[distance-1]+=n->label().length();
         }
         n->markAsVisible();
         maxNodes--;
         // add direct children
         if (n->m_children)
         {
           QListIterator<DotNode> li(*n->m_children);
           DotNode *dn;
           for (li.toFirst();(dn=li.current());++li)
           {
             childQueue.append(dn);
           }
         }
       }
     }
     if (includeParents && parentQueue.count()>0)
     {
       DotNode *n = parentQueue.take(0);
       if ((!n->isVisible() || firstNode) && n->distance()<=maxDistance) // not yet processed
       {
         firstNode=FALSE;
         int distance = n->distance();
         if (distance>0)
         {
           int oldSize = (int)parentTreeWidth.size();
           if (distance>oldSize)
           {
             parentTreeWidth.resize(QMAX(parentTreeWidth.size(),(uint)distance));
             int i; for (i=oldSize;i<distance;i++) parentTreeWidth[i]=0;
           }
           parentTreeWidth[distance-1]+=n->label().length();
         }
         n->markAsVisible();
         maxNodes--;
         // add direct parents
         if (n->m_parents)
         {
           QListIterator<DotNode> li(*n->m_parents);
           DotNode *dn;
           for (li.toFirst();(dn=li.current());++li)
           {
             parentQueue.append(dn);
           }
         }
       }
     }
   }
   if (Config_getBool("UML_LOOK")) return FALSE; // UML graph are always top to bottom
   int maxWidth=0;
   int maxHeight=(int)QMAX(childTreeWidth.size(),parentTreeWidth.size());
   uint i;
   for (i=0;i<childTreeWidth.size();i++)
   {
     if (childTreeWidth.at(i)>maxWidth) maxWidth=childTreeWidth.at(i);
   }
   for (i=0;i<parentTreeWidth.size();i++)
   {
     if (parentTreeWidth.at(i)>maxWidth) maxWidth=parentTreeWidth.at(i);
   }
   //printf("max tree width=%d, max tree height=%d\n",maxWidth,maxHeight);
   return maxWidth>80 && maxHeight<12; // used metric to decide to render the tree
                                       // from left to right instead of top to bottom,
                                       // with the idea to render very wide trees in
                                       // left to right order.
 }

QCString DotClassGraph::diskName ( ) const

Definition at line 3112 of file dot.cpp.

 {
   QCString result=m_diskName.copy();
   switch (m_graphType)
   {
     case DotNode::Collaboration:
       result+="_coll_graph";
       break;
     //case Interface:
     //  result+="_intf_graph";
     //  break;
     case DotNode::Inheritance:
       result+="_inherit_graph";
       break;
     default:
       ASSERT(0);
       break;
   }
   return result;
 }

bool DotClassGraph::isTooBig ( ) const

Definition at line 2997 of file dot.cpp.

 {
   static int maxNodes = Config_getInt("DOT_GRAPH_MAX_NODES");
   int numNodes = 0;
   numNodes+= m_startNode->m_children ? m_startNode->m_children->count() : 0;
   if (m_graphType==DotNode::Inheritance)
   {
     numNodes+= m_startNode->m_parents ? m_startNode->m_parents->count() : 0;
   }
   return numNodes>=maxNodes;
 }

bool DotClassGraph::isTrivial ( ) const

Definition at line 2988 of file dot.cpp.

 {
   static bool umlLook = Config_getBool("UML_LOOK");
   if (m_graphType==DotNode::Inheritance)
     return m_startNode->m_children==0 && m_startNode->m_parents==0;
   else
     return !umlLook && m_startNode->m_children==0;
 }

void DotClassGraph::writeDEF ( FTextStream & t )

Definition at line 3330 of file dot.cpp.

 {
   QDictIterator<DotNode> dni(*m_usedNodes);
   DotNode *node;
   for (;(node=dni.current());++dni)
   {
     node->writeDEF(t);
   }
 }

void DotClassGraph::writeDocbook ( FTextStream & t )

Definition at line 3320 of file dot.cpp.

 {
   QDictIterator<DotNode> dni(*m_usedNodes);
   DotNode *node;
   for (;(node=dni.current());++dni)
   {
     node->writeDocbook(t,TRUE);
   }
 }

QCString DotClassGraph::writeGraph	(	FTextStream &	t,
		GraphOutputFormat	gf,
		EmbeddedOutputFormat	ef,
		const char *	path,
		const char *	fileName,
		const char *	relPath,
		bool	TBRank = `TRUE`,
		bool	imageMap = `TRUE`,
		int	graphId = `-1`
	)		const

Definition at line 3133 of file dot.cpp.

 {
   QDir d(path);
   // store the original directory
   if (!d.exists())
   {
     err("Output dir %s does not exist!\n",path); exit(1);
   }
   static bool usePDFLatex = Config_getBool("USE_PDFLATEX");
 
   QCString baseName;
   QCString mapName;
   switch (m_graphType)
   {
     case DotNode::Collaboration:
       mapName="coll_map";
       break;
     //case Interface:
     //  mapName="intf_map";
     //  break;
     case DotNode::Inheritance:
       mapName="inherit_map";
       break;
     default:
       ASSERT(0);
       break;
   }
   baseName = convertNameToFile(diskName());
 
   // derive target file names from baseName
   QCString imgExt = getDotImageExtension();
   QCString imgFmt = Config_getEnum("DOT_IMAGE_FORMAT");
   QCString absBaseName = d.absPath().utf8()+"/"+baseName;
   QCString absDotName  = absBaseName+".dot";
   QCString absMapName  = absBaseName+".map";
   QCString absPdfName  = absBaseName+".pdf";
   QCString absEpsName  = absBaseName+".eps";
   QCString absImgName  = absBaseName+"."+imgExt;
 
   bool regenerate = FALSE;
   if (updateDotGraph(m_startNode,
                  m_graphType,
                  absBaseName,
                  graphFormat,
                  m_lrRank,
                  m_graphType==DotNode::Inheritance,
                  TRUE,
                  m_startNode->label()
                 ) ||
       !checkDeliverables(graphFormat==GOF_BITMAP ? absImgName : 
                          usePDFLatex    ? absPdfName : absEpsName,
                          graphFormat==GOF_BITMAP && generateImageMap ? absMapName : QCString())
      )
   {
     regenerate=TRUE;
     if (graphFormat==GOF_BITMAP) // run dot to create a bitmap image
     {
       DotRunner *dotRun = new DotRunner(absDotName,
                               d.absPath().data(),TRUE,absImgName);
       dotRun->addJob(imgFmt,absImgName);
       if (generateImageMap) dotRun->addJob(MAP_CMD,absMapName);
       DotManager::instance()->addRun(dotRun);
 
     }
     else if (graphFormat==GOF_EPS) // run dot to create a .eps image
     {
       DotRunner *dotRun = new DotRunner(absDotName,d.absPath().data(),FALSE);
       if (usePDFLatex)
       {
         dotRun->addJob("pdf",absPdfName);
       }
       else
       {
         dotRun->addJob("ps",absEpsName);
       }
       DotManager::instance()->addRun(dotRun);
     }
   }
   Doxygen::indexList->addImageFile(baseName+"."+imgExt);
 
   if (graphFormat==GOF_BITMAP && textFormat==EOF_DocBook)
   {
     out << "<para>" << endl;
     out << "    <figure>" << endl;
     out << "        <title>";
     switch (m_graphType)
     {
       case DotNode::Collaboration:
         out << "Collaboration graph";
         break;
       case DotNode::Inheritance:
         out << "Inheritance graph";
         break;
       default:
         ASSERT(0);
         break;
     }
     out << "</title>" << endl;
     out << "        <mediaobject>" << endl;
     out << "            <imageobject>" << endl;
     out << "                <imagedata";
     out << " width=\"50%\" align=\"center\" valign=\"middle\" scalefit=\"1\" fileref=\"" << relPath << baseName << "." << imgExt << "\">";
     out << "</imagedata>" << endl;
     out << "            </imageobject>" << endl;
     out << "        </mediaobject>" << endl;
     out << "    </figure>" << endl;
     out << "</para>" << endl;
   }
   else if (graphFormat==GOF_BITMAP && generateImageMap) // produce HTML to include the image
   {
     QCString mapLabel = escapeCharsInString(m_startNode->m_label,FALSE)+"_"+
                         escapeCharsInString(mapName,FALSE);
     if (imgExt=="svg") // add link to SVG file without map file
     {
       out << "<div class=\"center\">";
       if (regenerate || !writeSVGFigureLink(out,relPath,baseName,absImgName)) // need to patch the links in the generated SVG file
       {
         if (regenerate)
         {
           DotManager::instance()->addSVGConversion(absImgName,relPath,FALSE,QCString(),TRUE,graphId);
         }
         int mapId = DotManager::instance()->addSVGObject(fileName,baseName,absImgName,relPath);
         out << "<!-- SVG " << mapId << " -->" << endl;
       }
       out << "</div>" << endl;
     }
     else // add link to bitmap file with image map
     {
       out << "<div class=\"center\">";
       out << "<img src=\"" << relPath << baseName << "." 
         << imgExt << "\" border=\"0\" usemap=\"#" 
         << mapLabel << "\" alt=\"";
       switch (m_graphType)
       {
         case DotNode::Collaboration:
           out << "Collaboration graph";
           break;
         case DotNode::Inheritance:
           out << "Inheritance graph";
           break;
         default:
           ASSERT(0);
           break;
       }
       out << "\"/>";
       out << "</div>" << endl;
       if (regenerate || !insertMapFile(out,absMapName,relPath,mapLabel))
       {
         int mapId = DotManager::instance()->addMap(fileName,absMapName,relPath,
             FALSE,QCString(),mapLabel);
         out << "<!-- MAP " << mapId << " -->" << endl;
       }
     }
   }
   else if (graphFormat==GOF_EPS) // produce tex to include the .eps image
   {
     if (regenerate || !writeVecGfxFigure(out,baseName,absBaseName))
     {
       int figId = DotManager::instance()->addFigure(fileName,baseName,absBaseName,FALSE /*TRUE*/);
       out << endl << "% FIG " << figId << endl;
     }
   }
   if (!regenerate) removeDotGraph(absDotName);
 
   return baseName;
 }

void DotClassGraph::writeXML ( FTextStream & t )

Definition at line 3310 of file dot.cpp.

 {
   QDictIterator<DotNode> dni(*m_usedNodes);
   DotNode *node;
   for (;(node=dni.current());++dni)
   {
     node->writeXML(t,TRUE);
   }
 }

Member Data Documentation

int DotClassGraph::m_curNodeNumber = 0

staticprivate

Definition at line 194 of file dot.h.

QCString DotClassGraph::m_diskName

private

Definition at line 196 of file dot.h.

DotNode::GraphType DotClassGraph::m_graphType

private

Definition at line 195 of file dot.h.

bool DotClassGraph::m_lrRank

private

Definition at line 197 of file dot.h.

DotNode* DotClassGraph::m_startNode

private

Definition at line 192 of file dot.h.

QDict<DotNode>* DotClassGraph::m_usedNodes

private

Definition at line 193 of file dot.h.

The documentation for this class was generated from the following files:

doxygen-1.8.11/src/dot.h
doxygen-1.8.11/src/dot.cpp

Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation