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

 *

 * 

 *

 *

 * Copyright (C) 1997-2008 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.

 *

 */

#ifndef _DOT_H

#define _DOT_H

#include "qtbc.h"

#include <qlist.h>

#include <qdict.h>

#include "sortdict.h"

#include "xmlwriter.h"

class ClassDef;

class FileDef;

class QTextStream;

class DotNodeList;

class ClassSDict;

class MemberDef;

class Definition;

class DirDef;

class GroupDef;

class DotGroupCollaboration;

enum GraphOutputFormat { BITMAP , EPS };

/** @brief Attributes of an edge of a dot graph */

struct EdgeInfo

{

  enum Colors { Blue=0, Green=1, Red=2, Purple=3, Grey=4, Orange=5 };

  enum Styles { Solid=0, Dashed=1 };

  EdgeInfo() : m_color(0), m_style(0), m_labColor(0) {}

 ~EdgeInfo() {}

  int m_color;

  int m_style;

  QCString m_label;

  QCString m_url;

  int m_labColor;

};

/** @brief A node in a dot graph */

class DotNode

{

  public:

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

    enum TruncState { Unknown, Truncated, Untruncated };

    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(QTextStream &t,GraphType gt,GraphOutputFormat f,

               bool topDown,bool toChildren,bool backArrows,bool reNumber);

    int  m_subgraphId;

    void clearWriteFlag();

    void writeXML(QTextStream &t,bool isClassGraph);

    void writeXML(XmlStream &t, bool isClassGraph);

    void writeXMLDITA(XmlStream &t, bool isClassGraph);

    void writeDEF(QTextStream &t);

    QCString label() const { return m_label; }

    int  number() const { return m_number; }

    bool isVisible() const { return m_visible; }

    TruncState isTruncated() const { return m_truncated; }

    int distance() const { return m_distance; }

  private:

    void colorConnectedNodes(int curColor);

    void writeBox(QTextStream &t,GraphType gt,GraphOutputFormat f,

                  bool hasNonReachableChildren, bool reNumber=FALSE);

    void writeArrow(QTextStream &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; // only works for acyclic graphs!

    void markAsVisible(bool b=TRUE) { m_visible=b; }

    void markAsTruncated(bool b=TRUE) { m_truncated=b ? Truncated : Untruncated; }

    int              m_number;

    QCString         m_label;     //!< label text

    QCString         m_tooltip;   //!< node's tooltip

    QCString         m_url;       //!< url of the node (format: remote$local)

    QList<DotNode>  *m_parents;   //!< list of parent nodes (incoming arrows)

    QList<DotNode>  *m_children;  //!< list of child nodes (outgoing arrows)

    QList<EdgeInfo> *m_edgeInfo;  //!< edge info for each child

    bool             m_deleted;   //!< used to mark a node as deleted

    bool             m_written;   //!< used to mark a node as written

    bool             m_hasDoc;    //!< used to mark a node as documented

    bool             m_isRoot;    //!< indicates if this is a root node

    ClassDef *       m_classDef;  //!< class representing this node (can be 0)

    bool             m_visible;   //!< is the node visible in the output

    TruncState       m_truncated; //!< does the node have non-visible children/parents

    int              m_distance;  //!< shortest path to the root node

    friend class DotGfxHierarchyTable;

    friend class DotClassGraph;

    friend class DotInclDepGraph;

    friend class DotNodeList;

    friend class DotCallGraph;

    friend class DotGroupCollaboration;

    friend QCString computeMd5Signature(

                      DotNode *root, GraphType gt,

                      GraphOutputFormat f, 

                      bool lrRank, bool renderParents,

                      bool backArrows,

                      QCString &graphStr

                     );

};

inline int DotNode::findParent( DotNode *n )

{

    if( !m_parents )

        return -1;

    return m_parents->find(n);

}

/** @brief Represents a graphical class hierarchy */

class DotGfxHierarchyTable

{

  public:

    DotGfxHierarchyTable();

   ~DotGfxHierarchyTable();

    void writeGraph(QTextStream &t,const char *path) const;

  private:

    void addHierarchy(DotNode *n,ClassDef *cd,bool hide);

    void addClassList(ClassSDict *cl);

    QList<DotNode> *m_rootNodes; 

    QDict<DotNode> *m_usedNodes; 

    static int      m_curNodeNumber;

    DotNodeList    *m_rootSubgraphs;

};

/** @brief Representation of a class inheritance or dependency graph */

class DotClassGraph

{

  public:

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

   ~DotClassGraph();

    bool isTrivial() const;

    bool isTooBig() const;

    QCString writeGraph(QTextStream &t,GraphOutputFormat f,const char *path,

                    const char *relPath, bool TBRank=TRUE,bool imageMap=TRUE) const;

    void writeXML(QTextStream &t);

    void writeDEF(QTextStream &t);

    void writeXML(XmlStream &t);

    void writeXMLDITA(XmlStream &t);

    QCString diskName() const;

  private:

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

    DotNode        *   m_startNode;

    QDict<DotNode> *   m_usedNodes;

    static int         m_curNodeNumber;

    DotNode::GraphType m_graphType;

    QCString           m_diskName;

    bool               m_lrRank;

};

/** @brief Representation of an include dependency graph */

class DotInclDepGraph

{

  public:

    DotInclDepGraph(FileDef *fd,bool inverse);

   ~DotInclDepGraph();

    QCString writeGraph(QTextStream &t, GraphOutputFormat f,const char *path,

                    const char *relPath,

                    bool writeImageMap=TRUE) const;

    bool isTrivial() const;

    bool isTooBig() const;

    QCString diskName() const;

    void writeXML(QTextStream &t);

    void writeXML(XmlStream &t);

  private:

    void buildGraph(DotNode *n,FileDef *fd,int distance);

    void determineVisibleNodes(QList<DotNode> &queue,int &maxNodes);

    void determineTruncatedNodes(QList<DotNode> &queue);

    DotNode        *m_startNode;

    QDict<DotNode> *m_usedNodes;

    static int      m_curNodeNumber;

    QCString        m_diskName;

    int             m_maxDistance;

    bool            m_inverse;

};

/** @brief Representation of an call graph */

class DotCallGraph

{

  public:

    DotCallGraph(MemberDef *md,bool inverse);

   ~DotCallGraph();

    QCString writeGraph(QTextStream &t, GraphOutputFormat f,

                        const char *path,const char *relPath,bool writeImageMap=TRUE) const;

    void buildGraph(DotNode *n,MemberDef *md,int distance);

    bool isTrivial() const;

    bool isTooBig() const;

    void determineVisibleNodes(QList<DotNode> &queue, int &maxNodes);

    void determineTruncatedNodes(QList<DotNode> &queue);

  private:

    DotNode        *m_startNode;

    static int      m_curNodeNumber;

    QDict<DotNode> *m_usedNodes;

    int             m_maxDistance;

    int             m_recDepth;

    bool            m_inverse;

    QCString        m_diskName;

    Definition *    m_scope;

};

/** @brief Representation of an directory dependency graph */

class DotDirDeps

{

  public:

    DotDirDeps(DirDef *dir);

   ~DotDirDeps();

    bool isTrivial() const;

    QCString writeGraph(QTextStream &out,

                        GraphOutputFormat format,

                        const char *path,

                        const char *relPath,

                        bool writeImageMap=TRUE) const;

  private:

    DirDef *m_dir;

};

/** @brief Representation of a group collaboration graph */

class DotGroupCollaboration

{

  public :

    enum EdgeType 

    {  tmember = 0,

       tclass,

       tnamespace,

       tfile,

       tpages,

       tdir,

       thierarchy 

    };

    class Link

    {

      public:

        Link(const QCString lab,const QCString &u) : label(lab), url(u) {}

        QCString label;

        QCString url;

    };

    class Edge

    {

      public :

        Edge(DotNode *start,DotNode *end,EdgeType type) 

          : pNStart(start), pNEnd(end), eType(type)

        { links.setAutoDelete(TRUE); }

        DotNode* pNStart;

        DotNode* pNEnd;

        EdgeType eType;

        QList<Link> links;

        void write( QTextStream &t ) const;

    };

    DotGroupCollaboration(GroupDef* gd);

    ~DotGroupCollaboration();

    QCString writeGraph(QTextStream &t, GraphOutputFormat format,

                    const char *path,const char *relPath,

                    bool writeImageMap=TRUE) const;

    void buildGraph(GroupDef* gd);

    bool isTrivial() const;

  private :

    void addCollaborationMember( Definition* def, QCString& url, EdgeType eType );

    void addMemberList( class MemberList* ml );

    void writeGraphHeader(QTextStream &t) const;

    Edge* addEdge( DotNode* _pNStart, DotNode* _pNEnd, EdgeType _eType,

                   const QCString& _label, const QCString& _url );

    DotNode        *m_rootNode;

    int             m_curNodeId;

    QDict<DotNode> *m_usedNodes;

    QCString        m_diskName;

    QList<Edge>     m_edges;

};

/** @brief Helper class to run dot from doxygen.

 */

class DotRunner

{

  public:

    /** Creates a runner for a dot \a file. */

    DotRunner(const char *file);

    /** Adds an additional job to the run.

     *  Performing multiple jobs one file can be faster.

     */

    void addJob(const char *format,const char *output);

    void addPostProcessing(const char *cmd,const char *args);

    /** Runs dot for all jobs added. */

    bool run();

  private:

    QList<QCString> m_jobs;

    QCString m_postArgs;

    QCString m_postCmd;

    QCString m_file;

};

/** Generated a graphs legend page */

void generateGraphLegend(const char *path);

void writeDotGraphFromFile(const char *inFile,const char *outDir,

                           const char *outFile,GraphOutputFormat format);

QString getDotImageMapFromFile(const QString& inFile, const QString& outDir,

                               const QCString& relPath,const QString &context);

void writeDotDirDepGraph(QTextStream &t,DirDef *dd);

#endif