DotNode Class Reference

#include <dot.h>

Public Types
enum	GraphType {   Dependency, Inheritance, Collaboration, Hierarchy,   CallGraph }
enum	TruncState { Unknown, Truncated, Untruncated }

Public Member Functions
	DotNode (int n, const char *lab, const char *tip, const char *url, bool rootNode=FALSE, ClassDef *cd=0)
	~DotNode ()
void	addChild (DotNode *n, int edgeColor=EdgeInfo::Purple, int edgeStyle=EdgeInfo::Solid, const char *edgeLab=0, const char *edgeURL=0, int edgeLabCol=-1)
void	addParent (DotNode *n)
void	deleteNode (DotNodeList &deletedList, SDict< DotNode > *skipNodes=0)
void	removeChild (DotNode *n)
void	removeParent (DotNode *n)
int	findParent (DotNode *n)
void	write (FTextStream &t, GraphType gt, GraphOutputFormat f, bool topDown, bool toChildren, bool backArrows, bool reNumber)
void	clearWriteFlag ()
void	writeXML (FTextStream &t, bool isClassGraph)
void	writeDocbook (FTextStream &t, bool isClassGraph)
void	writeDEF (FTextStream &t)
QCString	label () const
int	number () const
bool	isVisible () const
TruncState	isTruncated () const
int	distance () const

Public Attributes
int	m_subgraphId

Private Member Functions
void	colorConnectedNodes (int curColor)
void	writeBox (FTextStream &t, GraphType gt, GraphOutputFormat f, bool hasNonReachableChildren, bool reNumber=FALSE)
void	writeArrow (FTextStream &t, GraphType gt, GraphOutputFormat f, DotNode *cn, EdgeInfo *ei, bool topDown, bool pointBack=TRUE, bool reNumber=FALSE)
void	setDistance (int distance)
const DotNode *	findDocNode () const
void	markAsVisible (bool b=TRUE)
void	markAsTruncated (bool b=TRUE)

Private Attributes
int	m_number
QCString	m_label
	label text More...
QCString	m_tooltip
	node's tooltip More...
QCString	m_url
	url of the node (format: remote$local) More...
QList< DotNode > *	m_parents
	list of parent nodes (incoming arrows) More...
QList< DotNode > *	m_children
	list of child nodes (outgoing arrows) More...
QList< EdgeInfo > *	m_edgeInfo
	edge info for each child More...
bool	m_deleted
	used to mark a node as deleted More...
bool	m_written
	used to mark a node as written More...
bool	m_hasDoc
	used to mark a node as documented More...
bool	m_isRoot
	indicates if this is a root node More...
ClassDef *	m_classDef
	class representing this node (can be 0) More...
bool	m_visible
	is the node visible in the output More...
TruncState	m_truncated
	does the node have non-visible children/parents More...
int	m_distance
	shortest path to the root node More...

Friends
class	DotGfxHierarchyTable
class	DotClassGraph
class	DotInclDepGraph
class	DotNodeList
class	DotCallGraph
class	DotGroupCollaboration
class	DotInheritanceGraph
QCString	computeMd5Signature (DotNode *root, GraphType gt, GraphOutputFormat f, bool lrRank, bool renderParents, bool backArrows, const QCString &title, QCString &graphStr)

Detailed Description

A node in a dot graph

Definition at line 60 of file dot.h.

Member Enumeration Documentation

enum DotNode::GraphType

Enumerator
Dependency
Inheritance
Collaboration
Hierarchy
CallGraph

Definition at line 63 of file dot.h.

{ Dependency, Inheritance, Collaboration, Hierarchy, CallGraph };

enum DotNode::TruncState

Enumerator
Unknown
Truncated
Untruncated

Definition at line 64 of file dot.h.

{ Unknown, Truncated, Untruncated };

Constructor & Destructor Documentation

DotNode::DotNode	(	int	n,
		const char *	lab,
		const char *	tip,
		const char *	url,
		bool	rootNode = FALSE,
		ClassDef *	cd = 0
	)

Definition at line 1452 of file dot.cpp.

  : m_subgraphId(-1)
  , m_number(n)
  , m_label(lab)
  , m_tooltip(tip)
  , m_url(url)
  , m_parents(0)
  , m_children(0)
  , m_edgeInfo(0)
  , m_deleted(FALSE)
  , m_written(FALSE)
  , m_hasDoc(FALSE)
  , m_isRoot(isRoot)
  , m_classDef(cd)
  , m_visible(FALSE)
  , m_truncated(Unknown)
  , m_distance(1000)
{
}

DotNode::~DotNode

(

)

Definition at line 1473 of file dot.cpp.

{
  delete m_children;
  delete m_parents;
  delete m_edgeInfo;
}

Member Function Documentation

void DotNode::addChild	(	DotNode *	n,
		int	edgeColor = EdgeInfo::Purple,
		int	edgeStyle = EdgeInfo::Solid,
		const char *	edgeLab = 0,
		const char *	edgeURL = 0,
		int	edgeLabCol = -1
	)

Definition at line 1480 of file dot.cpp.

{
  if (m_children==0)
  {
    m_children = new QList<DotNode>;
    m_edgeInfo = new QList<EdgeInfo>;
    m_edgeInfo->setAutoDelete(TRUE);
  }
  m_children->append(n);
  EdgeInfo *ei = new EdgeInfo;
  ei->m_color = edgeColor;
  ei->m_style = edgeStyle; 
  ei->m_label = edgeLab;
  ei->m_url   = edgeURL;
  if (edgeLabCol==-1)
    ei->m_labColor=edgeColor;
  else
    ei->m_labColor=edgeLabCol;
  m_edgeInfo->append(ei);
}

void DotNode::addParent

(

DotNode *

n

)

Definition at line 1507 of file dot.cpp.

{
  if (m_parents==0)
  {
    m_parents = new QList<DotNode>;
  }
  m_parents->append(n);
}

void DotNode::clearWriteFlag

(

)

Definition at line 2168 of file dot.cpp.

{
  m_written=FALSE;
  if (m_parents!=0)
  {
    QListIterator<DotNode> dnlip(*m_parents);
    DotNode *pn;
    for (dnlip.toFirst();(pn=dnlip.current());++dnlip)
    {
      if (pn->m_written)
      {
        pn->clearWriteFlag();
      }
    }
  }
  if (m_children!=0)
  {
    QListIterator<DotNode> dnlic(*m_children);
    DotNode *cn;
    for (dnlic.toFirst();(cn=dnlic.current());++dnlic)
    {
      if (cn->m_written)
      {
        cn->clearWriteFlag();
      }
    }
  }
}

void DotNode::colorConnectedNodes ( int  curColor )

private

Definition at line 2197 of file dot.cpp.

{ 
  if (m_children)
  {
    QListIterator<DotNode> dnlic(*m_children);
    DotNode *cn;
    for (dnlic.toFirst();(cn=dnlic.current());++dnlic)
    {
      if (cn->m_subgraphId==-1) // uncolored child node
      {
        cn->m_subgraphId=curColor;
        cn->markAsVisible();
        cn->colorConnectedNodes(curColor);
        //printf("coloring node %s (%p): %d\n",cn->m_label.data(),cn,cn->m_subgraphId);
      }
    }
  }

  if (m_parents)
  {
    QListIterator<DotNode> dnlip(*m_parents);
    DotNode *pn;
    for (dnlip.toFirst();(pn=dnlip.current());++dnlip)
    {
      if (pn->m_subgraphId==-1) // uncolored parent node
      {
        pn->m_subgraphId=curColor;
        pn->markAsVisible();
        pn->colorConnectedNodes(curColor);
        //printf("coloring node %s (%p): %d\n",pn->m_label.data(),pn,pn->m_subgraphId);
      }
    }
  }
}

void DotNode::deleteNode	(	DotNodeList &	deletedList,
		SDict< DotNode > *	skipNodes = 0
	)

Definition at line 1526 of file dot.cpp.

{
  if (m_deleted) return; // avoid recursive loops in case the graph has cycles
  m_deleted=TRUE;
  if (m_parents!=0) // delete all parent nodes of this node
  {
    QListIterator<DotNode> dnlip(*m_parents);
    DotNode *pn;
    for (dnlip.toFirst();(pn=dnlip.current());++dnlip)
    {
      //pn->removeChild(this);
      pn->deleteNode(deletedList,skipNodes);
    }
  }
  if (m_children!=0) // delete all child nodes of this node
  {
    QListIterator<DotNode> dnlic(*m_children);
    DotNode *cn;
    for (dnlic.toFirst();(cn=dnlic.current());++dnlic)
    {
      //cn->removeParent(this);
      cn->deleteNode(deletedList,skipNodes);
    }
  }
  // add this node to the list of deleted nodes.
  //printf("skipNodes=%p find(%p)=%p\n",skipNodes,this,skipNodes ? skipNodes->find((int)this) : 0);
  if (skipNodes==0 || skipNodes->find((char*)this)==0)
  {
    //printf("deleting\n");
    deletedList.append(this);
  }
}

int DotNode::distance ( ) const

inline

Definition at line 91 of file dot.h.

{ return m_distance; }

const DotNode * DotNode::findDocNode ( ) const

private

Definition at line 2232 of file dot.cpp.

{
  if (!m_url.isEmpty()) return this;
  //printf("findDocNode(): `%s'\n",m_label.data());
  if (m_parents)
  {
    QListIterator<DotNode> dnli(*m_parents);
    DotNode *pn;
    for (dnli.toFirst();(pn=dnli.current());++dnli)
    {
      if (!pn->m_hasDoc)
      {
        pn->m_hasDoc=TRUE;
        const DotNode *dn = pn->findDocNode();
        if (dn) return dn;
      }
    }
  }
  if (m_children)
  {
    QListIterator<DotNode> dnli(*m_children);
    DotNode *cn;
    for (dnli.toFirst();(cn=dnli.current());++dnli)
    {
      if (!cn->m_hasDoc)
      {
        cn->m_hasDoc=TRUE;
        const DotNode *dn = cn->findDocNode();
        if (dn) return dn;
      }
    }
  }
  return 0;
}

int DotNode::findParent ( DotNode *  n )

inline

Definition at line 778 of file dot.cpp.

{
  if ( !m_parents ) return -1;
  return m_parents->find(n);
}

TruncState DotNode::isTruncated ( ) const

inline

Definition at line 90 of file dot.h.

{ return m_truncated; }

bool DotNode::isVisible ( ) const

inline

Definition at line 89 of file dot.h.

{ return m_visible; }

QCString DotNode::label ( ) const

inline

Definition at line 87 of file dot.h.

{ return m_label; }

void DotNode::markAsTruncated ( bool  b = TRUE )

inlineprivate

Definition at line 102 of file dot.h.

{ m_truncated=b ? Truncated : Untruncated; }

void DotNode::markAsVisible ( bool  b = TRUE )

inlineprivate

Definition at line 101 of file dot.h.

{ m_visible=b; }

int DotNode::number ( ) const

inline

Definition at line 88 of file dot.h.

{ return m_number; }

void DotNode::removeChild

(

DotNode *

n

)

Definition at line 1516 of file dot.cpp.

{
  if (m_children) m_children->remove(n);
}

void DotNode::removeParent

(

DotNode *

n

)

Definition at line 1521 of file dot.cpp.

{
  if (m_parents) m_parents->remove(n);
}

void DotNode::setDistance ( int  distance )

private

Definition at line 1559 of file dot.cpp.

{
  if (distance<m_distance) m_distance = distance;
}

void DotNode::write	(	FTextStream &	t,
		GraphType	gt,
		GraphOutputFormat	f,
		bool	topDown,
		bool	toChildren,
		bool	backArrows,
		bool	reNumber
	)

Definition at line 1906 of file dot.cpp.

{
  //printf("DotNode::write(%d) name=%s this=%p written=%d visible=%d\n",m_distance,m_label.data(),this,m_written,m_visible);
  if (m_written) return; // node already written to the output
  if (!m_visible) return; // node is not visible
  writeBox(t,gt,format,m_truncated==Truncated,reNumber);
  m_written=TRUE;
  QList<DotNode> *nl = toChildren ? m_children : m_parents; 
  if (nl)
  {
    if (toChildren)
    {
      QListIterator<DotNode>  dnli1(*nl);
      QListIterator<EdgeInfo> dnli2(*m_edgeInfo);
      DotNode *cn;
      for (dnli1.toFirst();(cn=dnli1.current());++dnli1,++dnli2)
      {
        if (cn->isVisible())
        {
          //printf("write arrow %s%s%s\n",label().data(),backArrows?"<-":"->",cn->label().data());
          writeArrow(t,gt,format,cn,dnli2.current(),topDown,backArrows,reNumber);
        }
        cn->write(t,gt,format,topDown,toChildren,backArrows,reNumber);
      }
    }
    else // render parents
    {
      QListIterator<DotNode> dnli(*nl);
      DotNode *pn;
      for (dnli.toFirst();(pn=dnli.current());++dnli)
      {
        if (pn->isVisible())
        {
          //printf("write arrow %s%s%s\n",label().data(),backArrows?"<-":"->",pn->label().data());
          writeArrow(t,
              gt,
              format,
              pn,
              pn->m_edgeInfo->at(pn->m_children->findRef(this)),
              FALSE,
              backArrows,
              reNumber
              );
        }
        pn->write(t,gt,format,TRUE,FALSE,backArrows,reNumber);
      }
    }
  }
  //printf("end DotNode::write(%d) name=%s\n",distance,m_label.data());
}

void DotNode::writeArrow ( FTextStream &  t, GraphType  gt, GraphOutputFormat  f, DotNode *  cn, EdgeInfo *  ei, bool  topDown, bool  pointBack = TRUE, bool  reNumber = FALSE  )

private

Definition at line 1854 of file dot.cpp.

{
  t << "  Node";
  if (topDown) 
    t << reNumberNode(cn->number(),reNumber); 
  else 
    t << reNumberNode(m_number,reNumber);
  t << " -> Node";
  if (topDown) 
    t << reNumberNode(m_number,reNumber); 
  else 
    t << reNumberNode(cn->number(),reNumber);
  t << " [";

  static bool umlLook = Config_getBool("UML_LOOK");
  const EdgeProperties *eProps = umlLook ? &umlEdgeProps : &normalEdgeProps;
  QCString aStyle = eProps->arrowStyleMap[ei->m_color];
  bool umlUseArrow = aStyle=="odiamond";

  if (pointBack && !umlUseArrow) t << "dir=\"back\",";
  t << "color=\"" << eProps->edgeColorMap[ei->m_color] 
    << "\",fontsize=\"" << FONTSIZE << "\",";
  t << "style=\"" << eProps->edgeStyleMap[ei->m_style] << "\"";
  if (!ei->m_label.isEmpty())
  {
    t << ",label=\" " << convertLabel(ei->m_label) << "\" ";
  }
  if (umlLook &&
      eProps->arrowStyleMap[ei->m_color] && 
      (gt==Inheritance || gt==Collaboration)
     )
  {
    bool rev = pointBack;
    if (umlUseArrow) rev=!rev; // UML use relates has arrow on the start side
    if (rev) 
      t << ",arrowtail=\"" << eProps->arrowStyleMap[ei->m_color] << "\""; 
    else 
      t << ",arrowhead=\"" << eProps->arrowStyleMap[ei->m_color] << "\"";
  }

  if (format==GOF_BITMAP) t << ",fontname=\"" << FONTNAME << "\"";
  t << "];" << endl; 
}

void DotNode::writeBox ( FTextStream &  t, GraphType  gt, GraphOutputFormat  f, bool  hasNonReachableChildren, bool  reNumber = FALSE  )

private

Definition at line 1722 of file dot.cpp.

{
  const char *labCol = 
          m_url.isEmpty() ? "grey75" :  // non link
           (
            (hasNonReachableChildren) ? "red" : "black"
           );
  t << "  Node" << reNumberNode(m_number,reNumber) << " [label=\"";
  static bool umlLook = Config_getBool("UML_LOOK");

  if (m_classDef && umlLook && (gt==Inheritance || gt==Collaboration))
  {
    // add names shown as relations to a dictionary, so we don't show
    // them as attributes as well
    QDict<void> arrowNames(17);
    if (m_edgeInfo)
    {
      // for each edge
      QListIterator<EdgeInfo> li(*m_edgeInfo);
      EdgeInfo *ei;
      for (li.toFirst();(ei=li.current());++li)
      {
        if (!ei->m_label.isEmpty()) // labels joined by \n
        {
          int li=ei->m_label.find('\n');
          int p=0;
          QCString lab;
          while ((li=ei->m_label.find('\n',p))!=-1)
          {
            lab = stripProtectionPrefix(ei->m_label.mid(p,li-p));
            arrowNames.insert(lab,(void*)0x8);
            p=li+1;
          }
          lab = stripProtectionPrefix(ei->m_label.right(ei->m_label.length()-p));
          arrowNames.insert(lab,(void*)0x8);
        }
      }
    }

    //printf("DotNode::writeBox for %s\n",m_classDef->name().data());
    static bool extractPrivate = Config_getBool("EXTRACT_PRIVATE");
    t << "{" << convertLabel(m_label);
    t << "\\n|";
    writeBoxMemberList(t,'+',m_classDef->getMemberList(MemberListType_pubAttribs),m_classDef,FALSE,&arrowNames);
    writeBoxMemberList(t,'+',m_classDef->getMemberList(MemberListType_pubStaticAttribs),m_classDef,TRUE,&arrowNames);
    writeBoxMemberList(t,'+',m_classDef->getMemberList(MemberListType_properties),m_classDef,FALSE,&arrowNames);
    writeBoxMemberList(t,'~',m_classDef->getMemberList(MemberListType_pacAttribs),m_classDef,FALSE,&arrowNames);
    writeBoxMemberList(t,'~',m_classDef->getMemberList(MemberListType_pacStaticAttribs),m_classDef,TRUE,&arrowNames);
    writeBoxMemberList(t,'#',m_classDef->getMemberList(MemberListType_proAttribs),m_classDef,FALSE,&arrowNames);
    writeBoxMemberList(t,'#',m_classDef->getMemberList(MemberListType_proStaticAttribs),m_classDef,TRUE,&arrowNames);
    if (extractPrivate)
    {
      writeBoxMemberList(t,'-',m_classDef->getMemberList(MemberListType_priAttribs),m_classDef,FALSE,&arrowNames);
      writeBoxMemberList(t,'-',m_classDef->getMemberList(MemberListType_priStaticAttribs),m_classDef,TRUE,&arrowNames);
    }
    t << "|";
    writeBoxMemberList(t,'+',m_classDef->getMemberList(MemberListType_pubMethods),m_classDef);
    writeBoxMemberList(t,'+',m_classDef->getMemberList(MemberListType_pubStaticMethods),m_classDef,TRUE);
    writeBoxMemberList(t,'+',m_classDef->getMemberList(MemberListType_pubSlots),m_classDef);
    writeBoxMemberList(t,'~',m_classDef->getMemberList(MemberListType_pacMethods),m_classDef);
    writeBoxMemberList(t,'~',m_classDef->getMemberList(MemberListType_pacStaticMethods),m_classDef,TRUE);
    writeBoxMemberList(t,'#',m_classDef->getMemberList(MemberListType_proMethods),m_classDef);
    writeBoxMemberList(t,'#',m_classDef->getMemberList(MemberListType_proStaticMethods),m_classDef,TRUE);
    writeBoxMemberList(t,'#',m_classDef->getMemberList(MemberListType_proSlots),m_classDef);
    if (extractPrivate)
    {
      writeBoxMemberList(t,'-',m_classDef->getMemberList(MemberListType_priMethods),m_classDef);
      writeBoxMemberList(t,'-',m_classDef->getMemberList(MemberListType_priStaticMethods),m_classDef,TRUE);
      writeBoxMemberList(t,'-',m_classDef->getMemberList(MemberListType_priSlots),m_classDef);
    }
    if (m_classDef->getLanguage()!=SrcLangExt_Fortran &&
        m_classDef->getMemberGroupSDict())
    {
      MemberGroupSDict::Iterator mgdi(*m_classDef->getMemberGroupSDict());
      MemberGroup *mg;
      for (mgdi.toFirst();(mg=mgdi.current());++mgdi)
      {
        if (mg->members())
        {
          writeBoxMemberList(t,'*',mg->members(),m_classDef,FALSE,&arrowNames);
        }
      }
    }
    t << "}";
  }
  else // standard look
  {
    t << convertLabel(m_label);
  }
  t << "\",height=0.2,width=0.4";
  if (m_isRoot)
  {
    t << ",color=\"black\", fillcolor=\"grey75\", style=\"filled\", fontcolor=\"black\"";
  }
  else 
  {
    static bool dotTransparent = Config_getBool("DOT_TRANSPARENT");
    if (!dotTransparent)
    {
      t << ",color=\"" << labCol << "\", fillcolor=\"";
      t << "white";
      t << "\", style=\"filled\"";
    }
    else
    {
      t << ",color=\"" << labCol << "\"";
    }
    if (!m_url.isEmpty())
    {
      int anchorPos = m_url.findRev('#');
      if (anchorPos==-1)
      {
        t << ",URL=\"" << m_url << Doxygen::htmlFileExtension << "\"";
      }
      else
      {
        t << ",URL=\"" << m_url.left(anchorPos) << Doxygen::htmlFileExtension
          << m_url.right(m_url.length()-anchorPos) << "\"";
      }
    }
    if (!m_tooltip.isEmpty())
    {
      t << ",tooltip=\"" << escapeTooltip(m_tooltip) << "\"";
    }
  }
  t << "];" << endl; 
}

void DotNode::writeDEF

(

FTextStream &

t

)

Definition at line 2103 of file dot.cpp.

{
  const char* nodePrefix = "        node-";

  t << "      node = {" << endl;
  t << nodePrefix << "id    = " << m_number << ';' << endl;
  t << nodePrefix << "label = '" << m_label << "';" << endl;

  if (!m_url.isEmpty())
  {
    QCString url(m_url);
    const char *refPtr = url.data();
    char *urlPtr = strchr(url.rawData(),'$');
    if (urlPtr)
    {
      *urlPtr++='\0';
      t << nodePrefix << "link = {" << endl << "  "
        << nodePrefix << "link-id = '" << urlPtr << "';" << endl;

      if (*refPtr!='\0')
      {
        t << "  " << nodePrefix << "link-external = '"
          << refPtr << "';" << endl;
      }
      t << "        };" << endl;
    }
  }
  if (m_children)
  {
    QListIterator<DotNode> nli(*m_children);
    QListIterator<EdgeInfo> eli(*m_edgeInfo);
    DotNode *childNode;
    EdgeInfo *edgeInfo;
    for (;(childNode=nli.current());++nli,++eli)
    {
      edgeInfo=eli.current();
      t << "        node-child = {" << endl;
      t << "          child-id = '" << childNode->m_number << "';" << endl;
      t << "          relation = ";

      switch(edgeInfo->m_color)
      {
        case EdgeInfo::Blue:    t << "public-inheritance"; break;
        case EdgeInfo::Green:   t << "protected-inheritance"; break;
        case EdgeInfo::Red:     t << "private-inheritance"; break;
        case EdgeInfo::Purple:  t << "usage"; break;
        case EdgeInfo::Orange:  t << "template-instance"; break;
        case EdgeInfo::Orange2: t << "type-constraint"; break;
        case EdgeInfo::Grey:    ASSERT(0); break;
      }
      t << ';' << endl;

      if (!edgeInfo->m_label.isEmpty()) 
      {
        t << "          edgelabel = <<_EnD_oF_dEf_TeXt_" << endl
          << edgeInfo->m_label << endl
          << "_EnD_oF_dEf_TeXt_;" << endl;
      }
      t << "        }; /* node-child */" << endl;
    } /* for (;childNode...) */
  }
  t << "      }; /* node */" << endl;
}

void DotNode::writeDocbook	(	FTextStream &	t,
		bool	isClassGraph
	)

Definition at line 2033 of file dot.cpp.

{
  t << "      <node id=\"" << m_number << "\">" << endl;
  t << "        <label>" << convertToXML(m_label) << "</label>" << endl;
  if (!m_url.isEmpty())
  {
    QCString url(m_url);
    const char *refPtr = url.data();
    char *urlPtr = strchr(url.rawData(),'$');
    if (urlPtr)
    {
      *urlPtr++='\0';
      t << "        <link refid=\"" << convertToXML(urlPtr) << "\"";
      if (*refPtr!='\0')
      {
        t << " external=\"" << convertToXML(refPtr) << "\"";
      }
      t << "/>" << endl;
    }
  }
  if (m_children)
  {
    QListIterator<DotNode> nli(*m_children);
    QListIterator<EdgeInfo> eli(*m_edgeInfo);
    DotNode *childNode;
    EdgeInfo *edgeInfo;
    for (;(childNode=nli.current());++nli,++eli)
    {
      edgeInfo=eli.current();
      t << "        <childnode refid=\"" << childNode->m_number << "\" relation=\"";
      if (isClassGraph)
      {
        switch(edgeInfo->m_color)
        {
          case EdgeInfo::Blue:    t << "public-inheritance"; break;
          case EdgeInfo::Green:   t << "protected-inheritance"; break;
          case EdgeInfo::Red:     t << "private-inheritance"; break;
          case EdgeInfo::Purple:  t << "usage"; break;
          case EdgeInfo::Orange:  t << "template-instance"; break;
          case EdgeInfo::Orange2: t << "type-constraint"; break;
          case EdgeInfo::Grey:    ASSERT(0); break;
        }
      }
      else // include graph
      {
        t << "include";
      }
      t << "\">" << endl;
      if (!edgeInfo->m_label.isEmpty())
      {
        int p=0;
        int ni;
        while ((ni=edgeInfo->m_label.find('\n',p))!=-1)
        {
          t << "          <edgelabel>"
            << convertToXML(edgeInfo->m_label.mid(p,ni-p))
            << "</edgelabel>" << endl;
          p=ni+1;
        }
        t << "          <edgelabel>"
          << convertToXML(edgeInfo->m_label.right(edgeInfo->m_label.length()-p))
          << "</edgelabel>" << endl;
      }
      t << "        </childnode>" << endl;
    }
  }
  t << "      </node>" << endl;
}

void DotNode::writeXML	(	FTextStream &	t,
		bool	isClassGraph
	)

Definition at line 1964 of file dot.cpp.

{
  t << "      <node id=\"" << m_number << "\">" << endl;
  t << "        <label>" << convertToXML(m_label) << "</label>" << endl;
  if (!m_url.isEmpty())
  {
    QCString url(m_url);
    const char *refPtr = url.data();
    char *urlPtr = strchr(url.rawData(),'$');
    if (urlPtr)
    {
      *urlPtr++='\0';
      t << "        <link refid=\"" << convertToXML(urlPtr) << "\"";
      if (*refPtr!='\0')
      {
        t << " external=\"" << convertToXML(refPtr) << "\"";
      }
      t << "/>" << endl;
    }
  }
  if (m_children)
  {
    QListIterator<DotNode> nli(*m_children);
    QListIterator<EdgeInfo> eli(*m_edgeInfo);
    DotNode *childNode;
    EdgeInfo *edgeInfo;
    for (;(childNode=nli.current());++nli,++eli)
    {
      edgeInfo=eli.current();
      t << "        <childnode refid=\"" << childNode->m_number << "\" relation=\"";
      if (isClassGraph)
      {
        switch(edgeInfo->m_color)
        {
          case EdgeInfo::Blue:    t << "public-inheritance"; break;
          case EdgeInfo::Green:   t << "protected-inheritance"; break;
          case EdgeInfo::Red:     t << "private-inheritance"; break;
          case EdgeInfo::Purple:  t << "usage"; break;
          case EdgeInfo::Orange:  t << "template-instance"; break;
          case EdgeInfo::Orange2: t << "type-constraint"; break;
          case EdgeInfo::Grey:    ASSERT(0); break;
        }
      }
      else // include graph
      {
        t << "include"; 
      }
      t << "\">" << endl;
      if (!edgeInfo->m_label.isEmpty()) 
      {
        int p=0;
        int ni;
        while ((ni=edgeInfo->m_label.find('\n',p))!=-1)
        {
          t << "          <edgelabel>" 
            << convertToXML(edgeInfo->m_label.mid(p,ni-p))
            << "</edgelabel>" << endl;
          p=ni+1;
        }
        t << "          <edgelabel>" 
          << convertToXML(edgeInfo->m_label.right(edgeInfo->m_label.length()-p))
          << "</edgelabel>" << endl;
      }
      t << "        </childnode>" << endl;
    } 
  }
  t << "      </node>" << endl;
}

Friends And Related Function Documentation

QCString computeMd5Signature ( DotNode *  root, DotNode::GraphType  gt, GraphOutputFormat  f, bool  lrRank, bool  renderParents, bool  backArrows, const QCString &  title, QCString &  graphStr  )

friend

Computes a 16 byte md5 checksum for a given dot graph. The md5 checksum is returned as a 32 character ASCII string.

Definition at line 3018 of file dot.cpp.

{
  bool reNumber=TRUE;
    
  //printf("computeMd5Signature\n");
  QGString buf;
  FTextStream md5stream(&buf);
  writeGraphHeader(md5stream,title);
  if (lrRank)
  {
    md5stream << "  rankdir=\"LR\";" << endl;
  }
  root->clearWriteFlag();
  root->write(md5stream, 
      gt,
      format,
      gt!=DotNode::CallGraph && gt!=DotNode::Dependency,
      TRUE,
      backArrows,
      reNumber);
  if (renderParents && root->m_parents) 
  {
    QListIterator<DotNode>  dnli(*root->m_parents);
    DotNode *pn;
    for (dnli.toFirst();(pn=dnli.current());++dnli)
    {
      if (pn->isVisible()) 
      {
        root->writeArrow(md5stream,                              // stream
            gt,                                                  // graph type
            format,                                              // output format
            pn,                                                  // child node
            pn->m_edgeInfo->at(pn->m_children->findRef(root)),   // edge info
            FALSE,                                               // topDown?
            backArrows,                                          // point back?
            reNumber                                             // renumber nodes
            );
      }
      pn->write(md5stream,      // stream
                gt,             // graph type
                format,         // output format
                TRUE,           // topDown?
                FALSE,          // toChildren?
                backArrows,     // backward pointing arrows?
                reNumber        // renumber nodes?
               );
    }
  }
  writeGraphFooter(md5stream);
  uchar md5_sig[16];
  QCString sigStr(33);
  MD5Buffer((const unsigned char *)buf.data(),buf.length(),md5_sig);
  MD5SigToString(md5_sig,sigStr.rawData(),33);
  if (reNumber)
  {
    resetReNumbering();
  }
  graphStr=buf.data();
  //printf("md5: %s | file: %s\n",sigStr,baseName.data());
  return sigStr;
}

friend class DotCallGraph

friend

Definition at line 123 of file dot.h.

friend class DotClassGraph

friend

Definition at line 120 of file dot.h.

friend class DotGfxHierarchyTable

friend

Definition at line 119 of file dot.h.

friend class DotGroupCollaboration

friend

Definition at line 124 of file dot.h.

friend class DotInclDepGraph

friend

Definition at line 121 of file dot.h.

friend class DotInheritanceGraph

friend

Definition at line 125 of file dot.h.

friend class DotNodeList

friend

Definition at line 122 of file dot.h.

Member Data Documentation

QList<DotNode>* DotNode::m_children

private

list of child nodes (outgoing arrows)

Definition at line 108 of file dot.h.

ClassDef* DotNode::m_classDef

private

class representing this node (can be 0)

Definition at line 114 of file dot.h.

bool DotNode::m_deleted

private

used to mark a node as deleted

Definition at line 110 of file dot.h.

int DotNode::m_distance

private

shortest path to the root node

Definition at line 117 of file dot.h.

QList<EdgeInfo>* DotNode::m_edgeInfo

private

edge info for each child

Definition at line 109 of file dot.h.

bool DotNode::m_hasDoc

private

used to mark a node as documented

Definition at line 112 of file dot.h.

bool DotNode::m_isRoot

private

indicates if this is a root node

Definition at line 113 of file dot.h.

QCString DotNode::m_label

private

label text

Definition at line 104 of file dot.h.

int DotNode::m_number

private

Definition at line 103 of file dot.h.

QList<DotNode>* DotNode::m_parents

private

list of parent nodes (incoming arrows)

Definition at line 107 of file dot.h.

int DotNode::m_subgraphId

Definition at line 82 of file dot.h.

QCString DotNode::m_tooltip

private

node's tooltip

Definition at line 105 of file dot.h.

TruncState DotNode::m_truncated

private

does the node have non-visible children/parents

Definition at line 116 of file dot.h.

QCString DotNode::m_url

private

url of the node (format: remote$local)

Definition at line 106 of file dot.h.

bool DotNode::m_visible

private

is the node visible in the output

Definition at line 115 of file dot.h.

bool DotNode::m_written

private

used to mark a node as written

Definition at line 111 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