add new repoHEADmaster

28 files changed, 4788 insertions, 0 deletions

diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/arith.h b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/arith.h
new file mode 100644
index 0000000..812be55
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/arith.h
@@ -0,0 +1,102 @@
+/* $Id: arith.h,v 1.12 2008/05/15 14:51:09 ellson Exp $ $Revision: 1.12 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+/* geometric functions (e.g. on points and boxes) with application to, but
+ * no specific dependance on graphs */
+
+#ifndef GV_ARITH_H
+#define GV_ARITH_H
+
+/* for sincos */
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE 1
+#endif
+
+#include <limits.h>
+#ifdef HAVE_VALUES_H
+#include <values.h>
+#endif
+#include <math.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef MIN
+#undef MIN
+#endif
+#define MIN(a,b)	((a)<(b)?(a):(b))
+
+#ifdef MAX
+#undef MAX
+#endif
+#define MAX(a,b)	((a)>(b)?(a):(b))
+
+#ifdef ABS
+#undef ABS
+#endif
+#define ABS(a)		((a) >= 0 ? (a) : -(a))
+
+#ifndef INT_MAX
+#define	INT_MAX		((int)(~(unsigned)0 >> 1))
+#endif
+
+#ifndef INT_MIN
+#define INT_MIN		(-INT_MAX - 1)
+#endif
+
+#ifndef MAXSHORT
+#define	MAXSHORT	(0x7fff)
+#endif
+
+#ifndef MAXDOUBLE
+#define MAXDOUBLE	1.7976931348623157e+308
+#endif
+
+#ifndef MAXFLOAT
+#define MAXFLOAT	((float)3.40282347e+38)
+#endif
+
+#ifdef BETWEEN
+#undef BETWEEN
+#endif
+#define BETWEEN(a,b,c)	(((a) <= (b)) && ((b) <= (c)))
+
+#ifndef M_PI
+#define M_PI		3.14159265358979323846
+#endif
+
+#ifndef SQRT2
+#define SQRT2		1.41421356237309504880
+#endif
+
+#define ROUND(f)        ((f>=0)?(int)(f + .5):(int)(f - .5))
+#define RADIANS(deg)	((deg)/180.0 * M_PI)
+#define DEGREES(rad)	((rad)/M_PI * 180.0)
+
+#define SQR(a) ((a) * (a))
+
+#ifdef HAVE_SINCOS
+    extern void sincos(double x, double *s, double *c);
+#else
+# define sincos(x,s,c) *s = sin(x); *c = cos(x)
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/cdt.h b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/cdt.h
new file mode 100644
index 0000000..5471d62
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/cdt.h
@@ -0,0 +1,249 @@
+/* $Id: cdt.h,v 1.5 2007/05/11 17:06:35 erg Exp $ $Revision: 1.5 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+#ifndef _CDT_H
+#define _CDT_H		1
+
+/*	Public interface for the dictionary library
+**
+**      Written by Kiem-Phong Vo (05/25/96)
+*/
+
+#define CDT_VERSION	19991101L
+
+#define Void_t		void
+#define _ARG_(x)	x
+#ifndef NIL
+#define NIL(type) ((type)0)
+#endif
+
+#include <string.h>
+
+#if _PACKAGE_ast
+#  include	<ast_std.h>
+#elif _BLD_cdt
+#  include	"ast_common.h"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    typedef struct _dtlink_s Dtlink_t;
+    typedef struct _dthold_s Dthold_t;
+    typedef struct _dtdisc_s Dtdisc_t;
+    typedef struct _dtmethod_s Dtmethod_t;
+    typedef struct _dtdata_s Dtdata_t;
+    typedef struct _dt_s Dt_t;
+    typedef struct _dt_s Dict_t;	/* for libdict compatibility */
+    typedef struct _dtstat_s Dtstat_t;
+    typedef Void_t *(*Dtsearch_f) _ARG_((Dt_t *, Void_t *, int));
+    typedef Void_t *(*Dtmake_f) _ARG_((Dt_t *, Void_t *, Dtdisc_t *));
+    typedef void (*Dtfree_f) _ARG_((Dt_t *, Void_t *, Dtdisc_t *));
+    typedef int (*Dtcompar_f)
+	_ARG_((Dt_t *, Void_t *, Void_t *, Dtdisc_t *));
+    typedef unsigned int (*Dthash_f) _ARG_((Dt_t *, Void_t *, Dtdisc_t *));
+    typedef Void_t *(*Dtmemory_f)
+	_ARG_((Dt_t *, Void_t *, size_t, Dtdisc_t *));
+    typedef int (*Dtevent_f) _ARG_((Dt_t *, int, Void_t *, Dtdisc_t *));
+
+    struct _dtlink_s {
+	Dtlink_t *right;	/* right child          */
+	union {
+	    unsigned int _hash;	/* hash value           */
+	    Dtlink_t *_left;	/* left child           */
+	} hl;
+    };
+
+/* private structure to hold an object */
+    struct _dthold_s {
+	Dtlink_t hdr;		/* header               */
+	Void_t *obj;		/* user object          */
+    };
+
+/* method to manipulate dictionary structure */
+    struct _dtmethod_s {
+	Dtsearch_f searchf;	/* search function     */
+	int type;		/* type of operation    */
+    };
+
+/* stuff that may be in shared memory */
+    struct _dtdata_s {
+	int type;		/* type of dictionary                   */
+	Dtlink_t *here;		/* finger to last search element        */
+	union {
+	    Dtlink_t **_htab;	/* hash table                           */
+	    Dtlink_t *_head;	/* linked list                          */
+	} hh;
+	int ntab;		/* number of hash slots                 */
+	int size;		/* number of objects                    */
+	int loop;		/* number of nested loops               */
+    };
+
+/* structure to hold methods that manipulate an object */
+    struct _dtdisc_s {
+	int key;		/* where the key begins in an object    */
+	int size;		/* key size and type                    */
+	int link;		/* offset to Dtlink_t field             */
+	Dtmake_f makef;		/* object constructor                   */
+	Dtfree_f freef;		/* object destructor                    */
+	Dtcompar_f comparf;	/* to compare two objects               */
+	Dthash_f hashf;		/* to compute hash value of an object   */
+	Dtmemory_f memoryf;	/* to allocate/free memory              */
+	Dtevent_f eventf;	/* to process events                    */
+    };
+
+/* the dictionary structure itself */
+    struct _dt_s {
+	Dtsearch_f searchf;	/* search function                      */
+	Dtdisc_t *disc;		/* method to manipulate objs            */
+	Dtdata_t *data;		/* sharable data                        */
+	Dtmemory_f memoryf;	/* function to alloc/free memory        */
+	Dtmethod_t *meth;	/* dictionary method                    */
+	int type;		/* type information                     */
+	int nview;		/* number of parent view dictionaries   */
+	Dt_t *view;		/* next on viewpath                     */
+	Dt_t *walk;		/* dictionary being walked              */
+    };
+
+/* structure to get status of a dictionary */
+    struct _dtstat_s {
+	int dt_meth;		/* method type                          */
+	int dt_size;		/* number of elements                   */
+	int dt_n;		/* number of chains or levels           */
+	int dt_max;		/* max size of a chain or a level       */
+	int *dt_count;		/* counts of chains or levels by size   */
+    };
+
+/* supported storage methods */
+#define DT_SET		0000001	/* set with unique elements             */
+#define DT_BAG		0000002	/* multiset                             */
+#define DT_OSET		0000004	/* ordered set (self-adjusting tree)    */
+#define DT_OBAG		0000010	/* ordered multiset                     */
+#define DT_LIST		0000020	/* linked list                          */
+#define DT_STACK	0000040	/* stack                                */
+#define DT_QUEUE	0000100	/* queue                                */
+#define DT_METHODS	0000177	/* all currently supported methods      */
+
+/* asserts to dtdisc() */
+#define DT_SAMECMP	0000001	/* compare methods equivalent           */
+#define DT_SAMEHASH	0000002	/* hash methods equivalent              */
+
+/* types of search */
+#define DT_INSERT	0000001	/* insert object if not found           */
+#define DT_DELETE	0000002	/* delete object if found               */
+#define DT_SEARCH	0000004	/* look for an object                   */
+#define DT_NEXT		0000010	/* look for next element                */
+#define DT_PREV		0000020	/* find previous element                */
+#define DT_RENEW	0000040	/* renewing an object                   */
+#define DT_CLEAR	0000100	/* clearing all objects                 */
+#define DT_FIRST	0000200	/* get first object                     */
+#define DT_LAST		0000400	/* get last object                      */
+#define DT_MATCH	0001000	/* find object matching key             */
+#define DT_VSEARCH	0002000	/* search using internal representation */
+#define DT_ATTACH	0004000	/* attach an object to the dictionary   */
+#define DT_DETACH	0010000	/* attach an object to the dictionary   */
+
+/* events */
+#define DT_OPEN		1	/* a dictionary is being opened         */
+#define DT_CLOSE	2	/* a dictionary is being closed         */
+#define DT_DISC		3	/* discipline is about to be changed    */
+#define DT_METH		4	/* method is about to be changed        */
+
+#if _BLD_cdt && defined(__EXPORT__)
+#define extern	__EXPORT__
+#endif
+#if !_BLD_cdt && defined(GVDLL)
+#define extern	__declspec(dllimport)
+#endif
+#if !_BLD_cdt && defined(__IMPORT__)
+#define extern	__IMPORT__
+#endif
+     extern Dtmethod_t *Dtset;
+    extern Dtmethod_t *Dtbag;
+    extern Dtmethod_t *Dtoset;
+    extern Dtmethod_t *Dtobag;
+    extern Dtmethod_t *Dtlist;
+    extern Dtmethod_t *Dtstack;
+    extern Dtmethod_t *Dtqueue;
+
+/* compatibility stuff; will go away */
+#ifndef KPVDEL
+    extern Dtmethod_t *Dtorder;
+    extern Dtmethod_t *Dttree;
+    extern Dtmethod_t *Dthash;
+    extern Dtmethod_t _Dttree;
+    extern Dtmethod_t _Dthash;
+    extern Dtmethod_t _Dtlist;
+    extern Dtmethod_t _Dtqueue;
+    extern Dtmethod_t _Dtstack;
+#endif
+
+#undef extern
+#if _BLD_cdt && defined(__EXPORT__)
+#define extern	__EXPORT__
+#endif
+#if !_BLD_cdt && defined(__IMPORT__) && defined(__EXPORT__)
+#define extern	__IMPORT__
+#endif
+     extern Dt_t *dtopen _ARG_((Dtdisc_t *, Dtmethod_t *));
+    extern int dtclose _ARG_((Dt_t *));
+    extern Dt_t *dtview _ARG_((Dt_t *, Dt_t *));
+    extern Dtdisc_t *dtdisc _ARG_((Dt_t * dt, Dtdisc_t *, int));
+    extern Dtmethod_t *dtmethod _ARG_((Dt_t *, Dtmethod_t *));
+
+    extern Dtlink_t *dtflatten _ARG_((Dt_t *));
+    extern Dtlink_t *dtextract _ARG_((Dt_t *));
+    extern int dtrestore _ARG_((Dt_t *, Dtlink_t *));
+
+    extern int dtwalk
+	_ARG_((Dt_t *, int (*)(Dt_t *, Void_t *, Void_t *), Void_t *));
+
+    extern Void_t *dtrenew _ARG_((Dt_t *, Void_t *));
+
+    extern int dtsize _ARG_((Dt_t *));
+    extern int dtstat _ARG_((Dt_t *, Dtstat_t *, int));
+    extern unsigned int dtstrhash _ARG_((unsigned int, Void_t *, int));
+
+#undef extern
+
+#define _DT_(d)		((Dt_t*)(d))
+#define dtvnext(d)	(_DT_(d)->view)
+#define dtvcount(d)	(_DT_(d)->nview)
+#define dtvhere(d)	(_DT_(d)->walk)
+#define dtlink(d,e)	(((Dtlink_t*)(e))->right)
+#define dtobj(d,e)	((_DT_(d)->disc->link < 0) ? (((Dthold_t*)(e))->obj) : \
+				(Void_t*)((char*)(e) - _DT_(d)->disc->link) )
+#define dtfinger(d)	(_DT_(d)->data->here ? dtobj((d),_DT_(d)->data->here) : \
+				(Void_t*)(0) )
+#define dtfirst(d)	(*(_DT_(d)->searchf))((d),(Void_t*)(0),DT_FIRST)
+#define dtnext(d,o)	(*(_DT_(d)->searchf))((d),(Void_t*)(o),DT_NEXT)
+#define dtlast(d)	(*(_DT_(d)->searchf))((d),(Void_t*)(0),DT_LAST)
+#define dtprev(d,o)	(*(_DT_(d)->searchf))((d),(Void_t*)(o),DT_PREV)
+#define dtsearch(d,o)	(*(_DT_(d)->searchf))((d),(Void_t*)(o),DT_SEARCH)
+#define dtmatch(d,o)	(*(_DT_(d)->searchf))((d),(Void_t*)(o),DT_MATCH)
+#define dtinsert(d,o)	(*(_DT_(d)->searchf))((d),(Void_t*)(o),DT_INSERT)
+#define dtdelete(d,o)	(*(_DT_(d)->searchf))((d),(Void_t*)(o),DT_DELETE)
+#define dtattach(d,o)	(*(_DT_(d)->searchf))((d),(Void_t*)(o),DT_ATTACH)
+#define dtdetach(d,o)	(*(_DT_(d)->searchf))((d),(Void_t*)(o),DT_DETACH)
+#define dtclear(d)	(*(_DT_(d)->searchf))((d),(Void_t*)(0),DT_CLEAR)
+/* A linear congruential hash: h*17 + c + 97531 */
+#define dtcharhash(h,c)	((((unsigned int)(h))<<4) + ((unsigned int)(h)) + \
+			 ((unsigned char)(c)) + 97531 )
+#ifdef __cplusplus
+}
+#endif
+#endif				/* _CDT_H */
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/cgraph.h b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/cgraph.h
new file mode 100644
index 0000000..aa2c27d
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/cgraph.h
@@ -0,0 +1,454 @@
+/* $Id: cgraph.h,v 1.7 2008/04/28 16:35:09 erg Exp $ $Revision: 1.7 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+#ifndef ATT_GRAPH_H
+#define ATT_GRAPH_H
+
+#include		<cdt.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef FALSE
+#define FALSE (0)
+#endif
+#ifndef TRUE
+#define TRUE (!FALSE)
+#endif
+#ifndef NOT
+#define	NOT(x)			(!(x))
+#endif
+#ifndef NIL
+#define NIL(type)		((type)0)
+#endif
+#define NILgraph		NIL(Agraph_t*)
+#define NILnode			NIL(Agnode_t*)
+#define NILedge			NIL(Agedge_t*)
+#define NILsym			NIL(Agsym_t*)
+
+/* forward struct type declarations */
+typedef struct Agtag_s Agtag_t;
+typedef struct Agobj_s Agobj_t;	/* generic object header */
+typedef struct Agraph_s Agraph_t;	/* graph, subgraph (or hyperedge) */
+typedef struct Agnode_s Agnode_t;	/* node (atom) */
+typedef struct Agedge_s Agedge_t;	/* node pair */
+typedef struct Agdesc_s Agdesc_t;	/* graph descriptor */
+typedef struct Agmemdisc_s Agmemdisc_t;	/* memory allocator */
+typedef struct Agiddisc_s Agiddisc_t;	/* object ID allocator */
+typedef struct Agiodisc_s Agiodisc_t;	/* IO services */
+typedef struct Agdisc_s Agdisc_t;	/* union of client discipline methods */
+typedef struct Agdstate_s Agdstate_t;	/* client state (closures) */
+typedef struct Agsym_s Agsym_t;	/* string attribute descriptors */
+typedef struct Agattr_s Agattr_t;	/* string attribute container */
+typedef struct Agcbdisc_s Agcbdisc_t;	/* client event callbacks */
+typedef struct Agcbstack_s Agcbstack_t;	/* enclosing state for cbdisc */
+typedef struct Agclos_s Agclos_t;	/* common fields for graph/subgs */
+typedef struct Agrec_s Agrec_t;	/* generic runtime record */
+typedef struct Agdatadict_s Agdatadict_t;	/* set of dictionaries per graph */
+typedef struct Agedgepair_s Agedgepair_t;	/* the edge object */
+typedef struct Agsubnode_s Agsubnode_t;
+
+/* Header of a user record.  These records are attached by client programs
+dynamically at runtime.  A unique string ID must be given to each record
+attached to the same object.  Cgraph has functions to create, search for,
+and delete these records.   The records are maintained in a circular list,
+with obj->data pointing somewhere in the list.  The search function has
+an option to lock this pointer on a given record.  The application must
+be written so only one such lock is outstanding at a time. */
+
+struct Agrec_s {
+    char *name;
+    Agrec_t *next;
+    /* following this would be any programmer-defined data */
+};
+
+/* Object tag for graphs, nodes, and edges.  While there may be several structs
+for a given node or edges, there is only one unique ID (per main graph).  */
+struct Agtag_s {
+    unsigned objtype:2;		/* see literal tags below */
+    unsigned mtflock:1;		/* move-to-front lock, see above */
+    unsigned attrwf:1;		/* attrs written (parity, write.c) */
+    unsigned seq:(sizeof(unsigned) * 8 - 4);	/* sequence no. */
+    unsigned long id;		/* client  ID */
+};
+
+	/* object tags */
+#define AGRAPH				0	/* can't exceed 2 bits. see Agtag_t. */
+#define AGNODE				1
+#define AGOUTEDGE			2
+#define AGINEDGE			3	/* (1 << 1) indicates an edge tag.   */
+#define AGEDGE 				AGOUTEDGE	/* synonym in object kind args */
+
+	/* a generic graph/node/edge header */
+struct Agobj_s {
+    Agtag_t tag;
+    Agrec_t *data;
+};
+
+#define AGTAG(obj)		(((Agobj_t*)(obj))->tag)
+#define AGTYPE(obj)		(AGTAG(obj).objtype)
+#define AGID(obj)		(AGTAG(obj).id)
+#define AGSEQ(obj)		(AGTAG(obj).seq)
+#define AGATTRWF(obj)		(AGTAG(obj).attrwf)
+#define AGDATA(obj)		(((Agobj_t*)(obj))->data)
+
+/* This is the node struct allocated per graph (or subgraph).  It resides
+in the n_dict of the graph.  The node set is maintained by libdict, but
+transparently to libgraph callers.  Every node may be given an optional
+string name at its time of creation, or it is permissible to pass NIL(char*)
+for the name. */
+
+struct Agsubnode_s {		/* the node-per-graph-or-subgraph record */
+    Dtlink_t seq_link;		/* must be first */
+    Dtlink_t id_link;
+    Agnode_t *node;		/* the object */
+    Dtlink_t *in_id, *out_id;	/* by node/ID for random access */
+    Dtlink_t *in_seq, *out_seq;	/* by node/sequence for serial access */
+};
+
+struct Agnode_s {
+    Agobj_t base;
+    Agraph_t *root;
+    Agsubnode_t mainsub;	/* embedded for main graph */
+};
+
+struct Agedge_s {
+    Agobj_t base;
+    Dtlink_t id_link;		/* main graph only */
+    Dtlink_t seq_link;
+    Agnode_t *node;		/* the endpoint node */
+};
+
+struct Agedgepair_s {
+    Agedge_t out, in;
+};
+
+struct Agdesc_s {		/* graph descriptor */
+    unsigned directed:1;	/* if edges are asymmetric */
+    unsigned strict:1;		/* if and self, multi-edges forbidden */
+    unsigned maingraph:1;	/* if this is the top level graph */
+    unsigned flatlock:1;	/* if sets are flattened into lists in cdt */
+    unsigned no_write:1;	/* if a temporary subgraph */
+    unsigned has_attrs:1;	/* if string attr tables should be initialized */
+    unsigned has_cmpnd:1;	/* if may contain collapsed nodes */
+};
+
+/* disciplines for external resources needed by libgraph */
+
+struct Agmemdisc_s {		/* memory allocator */
+    void *(*open) (void);	/* independent of other resources */
+    void *(*alloc) (void *state, size_t req);
+    void *(*resize) (void *state, void *ptr, size_t old, size_t req);
+    void (*free) (void *state, void *ptr);
+    void (*close) (void *state);
+};
+
+struct Agiddisc_s {		/* object ID allocator */
+    void *(*open) (Agraph_t * g);	/* associated with a graph */
+    long (*map) (void *state, int objtype, char *str, unsigned long *id,
+		 int createflag);
+    long (*alloc) (void *state, int objtype, unsigned long id);
+    void (*free) (void *state, int objtype, unsigned long id);
+    char *(*print) (void *state, int objtype, unsigned long id);
+    void (*close) (void *state);
+};
+
+struct Agiodisc_s {
+    int (*afread) (void *chan, char *buf, int bufsize);
+    int (*putstr) (void *chan, char *str);
+    int (*flush) (void *chan);	/* sync */
+    /* error messages? */
+};
+
+struct Agdisc_s {		/* user's discipline */
+    Agmemdisc_t *mem;
+    Agiddisc_t *id;
+    Agiodisc_t *io;
+};
+
+	/* default resource disciplines */
+#if !defined(_BLD_cgraph) && defined(GVDLL)
+#define extern  __declspec(dllimport)
+#endif
+
+extern Agmemdisc_t AgMemDisc;
+extern Agiddisc_t AgIdDisc;
+extern Agiodisc_t AgIoDisc;
+
+extern Agdisc_t AgDefaultDisc;
+#undef extern
+
+struct Agdstate_s {
+    void *mem;
+    void *id;
+    /* IO must be initialized and finalized outside Cgraph,
+     * and channels (FILES) are passed as void* arguments. */
+};
+
+typedef void (*agobjfn_t) (Agraph_t * g, Agobj_t * obj, void *arg);
+typedef void (*agobjupdfn_t) (Agraph_t * g, Agobj_t * obj, void *arg,
+			      Agsym_t * sym);
+
+struct Agcbdisc_s {
+    struct {
+	agobjfn_t ins;
+	agobjupdfn_t mod;
+	agobjfn_t del;
+    } graph, node, edge;
+};
+
+struct Agcbstack_s {		/* object event callbacks */
+    Agcbdisc_t *f;		/* methods */
+    void *state;		/* closure */
+    Agcbstack_t *prev;		/* kept in a stack, unlike other disciplines */
+};
+
+struct Agclos_s {
+    Agdisc_t disc;		/* resource discipline functions */
+    Agdstate_t state;		/* resource closures */
+    Dict_t *strdict;		/* shared string dict */
+    unsigned long seq[3];	/* local object sequence number counter */
+    Agcbstack_t *cb;		/* user and system callback function stacks */
+    unsigned char callbacks_enabled;	/* issue user callbacks or hold them? */
+    Dict_t *lookup_by_name[3];
+    Dict_t *lookup_by_id[3];
+};
+
+struct Agraph_s {
+    Agobj_t base;
+    Agdesc_t desc;
+    Dtlink_t link;
+    Dict_t *n_seq;		/* the node set in sequence */
+    Dict_t *n_id;		/* the node set indexed by ID */
+    Dict_t *e_seq, *e_id;	/* holders for edge sets */
+    Dict_t *g_dict;		/* subgraphs - descendants */
+    Agraph_t *parent, *root;	/* subgraphs - ancestors */
+    Agclos_t *clos;		/* shared resources */
+};
+
+
+#if _PACKAGE_ast
+/* fine control of object callbacks */
+#   if defined(_BLD_cgraph) && defined(__EXPORT__)
+#	define extern  __EXPORT__
+#   endif
+#   if !defined(_BLD_cgraph) && defined(__IMPORT__)
+#	define extern  __IMPORT__
+#   endif
+#endif
+
+extern void agpushdisc(Agraph_t * g, Agcbdisc_t * disc, void *state);
+extern int agpopdisc(Agraph_t * g, Agcbdisc_t * disc);
+extern int agcallbacks(Agraph_t * g, int flag);	/* return prev value */
+
+/* graphs */
+extern Agraph_t *agopen(char *name, Agdesc_t desc, Agdisc_t * disc);
+extern int agclose(Agraph_t * g);
+extern Agraph_t *agread(void *chan, Agdisc_t * disc);
+extern void agreadline(int);
+extern void agsetfile(char *);
+extern Agraph_t *agconcat(Agraph_t * g, void *chan, Agdisc_t * disc);
+extern int agwrite(Agraph_t * g, void *chan);
+extern int agisdirected(Agraph_t * g);
+extern int agisundirected(Agraph_t * g);
+extern int agisstrict(Agraph_t * g);
+
+/* nodes */
+extern Agnode_t *agnode(Agraph_t * g, char *name, int createflag);
+extern Agnode_t *agidnode(Agraph_t * g, unsigned long id, int createflag);
+extern Agnode_t *agsubnode(Agraph_t * g, Agnode_t * n, int createflag);
+extern Agnode_t *agfstnode(Agraph_t * g);
+extern Agnode_t *agnxtnode(Agraph_t * g, Agnode_t * n);
+extern Agnode_t *aglstnode(Agraph_t * g);
+extern Agnode_t *agprvnode(Agraph_t * g, Agnode_t * n);
+
+extern Agsubnode_t *agsubrep(Agraph_t * g, Agnode_t * n);
+
+/* edges */
+extern Agedge_t *agedge(Agraph_t * g, Agnode_t * t, Agnode_t * h,
+			char *name, int createflag);
+extern Agedge_t *agidedge(Agraph_t * g, Agnode_t * t, Agnode_t * h,
+			  unsigned long id, int createflag);
+extern Agedge_t *agsubedge(Agraph_t * g, Agedge_t * e, int createflag);
+extern Agedge_t *agfstin(Agraph_t * g, Agnode_t * n);
+extern Agedge_t *agnxtin(Agraph_t * g, Agedge_t * e);
+extern Agedge_t *agfstout(Agraph_t * g, Agnode_t * n);
+extern Agedge_t *agnxtout(Agraph_t * g, Agedge_t * e);
+extern Agedge_t *agfstedge(Agraph_t * g, Agnode_t * n);
+extern Agedge_t *agnxtedge(Agraph_t * g, Agedge_t * e, Agnode_t * n);
+
+/* generic */
+extern Agraph_t *agraphof(void *);
+extern char *agnameof(void *);
+extern int agrelabel(void *obj, char *name);	/* scary */
+extern int agrelabel_node(Agnode_t * n, char *newname);
+extern int agdelete(Agraph_t * g, void *obj);
+extern long agdelsubg(Agraph_t * g, Agraph_t * sub);	/* could be agclose */
+extern int agdelnode(Agraph_t * g, Agnode_t * arg_n);
+extern int agdeledge(Agraph_t * g, Agedge_t * arg_e);
+extern int agobjkind(void *);
+
+/* strings */
+extern char *agstrdup(Agraph_t *, char *);
+extern char *agstrdup_html(Agraph_t *, char *);
+extern int aghtmlstr(char *);
+extern char *agstrbind(Agraph_t * g, char *);
+extern int agstrfree(Agraph_t *, char *);
+extern char *agstrcanon(char *, char *);
+char *agcanonStr(char *str);  /* manages its own buf */
+
+/* definitions for dynamic string attributes */
+struct Agattr_s {		/* dynamic string attributes */
+    Agrec_t h;			/* common data header */
+    Dict_t *dict;		/* shared dict to interpret attr field */
+    char **str;			/* the attribute string values */
+};
+
+struct Agsym_s {		/* symbol in one of the above dictionaries */
+    Dtlink_t link;
+    char *name;			/* attribute's name */
+    char *defval;		/* its default value for initialization */
+    int id;			/* its index in attr[] */
+    unsigned char kind;		/* referent object type */
+    unsigned char fixed;	/* immutable value */
+};
+
+struct Agdatadict_s {		/* set of dictionaries per graph */
+    Agrec_t h;			/* installed in list of graph recs */
+    struct {
+	Dict_t *n, *e, *g;
+    } dict;
+};
+
+extern Agsym_t *agattr(Agraph_t * g, int kind, char *name, char *value);
+extern Agsym_t *agattrsym(void *obj, char *name);
+extern Agsym_t *agnxtattr(Agraph_t * g, int kind, Agsym_t * attr);
+extern int      agcopyattr(void *oldobj, void *newobj);
+
+extern void *agbindrec(void *obj, char *name, unsigned int size,
+		       int move_to_front);
+extern Agrec_t *aggetrec(void *obj, char *name, int move_to_front);
+extern int agdelrec(void *obj, char *name);
+extern void aginit(Agraph_t * g, int kind, char *rec_name, int rec_size,
+		   int move_to_front);
+extern void agclean(Agraph_t * g, int kind, char *rec_name);
+
+extern char *agget(void *obj, char *name);
+extern char *agxget(void *obj, Agsym_t * sym);
+extern int agset(void *obj, char *name, char *value);
+extern int agxset(void *obj, Agsym_t * sym, char *value);
+extern int agsafeset(void* obj, char* name, char* value, char* def);
+
+/* defintions for subgraphs */
+extern Agraph_t *agsubg(Agraph_t * g, char *name, int cflag);	/* constructor */
+extern Agraph_t *agidsubg(Agraph_t * g, unsigned long id, int cflag);	/* constructor */
+extern Agraph_t *agfstsubg(Agraph_t * g), *agnxtsubg(Agraph_t * subg);
+extern Agraph_t *agparent(Agraph_t * g), *agroot(Agraph_t * g);
+
+/* set cardinality */
+extern int agnnodes(Agraph_t * g), agnedges(Agraph_t * g);
+extern int agdegree(Agraph_t * g, Agnode_t * n, int in, int out);
+
+/* memory */
+extern void *agalloc(Agraph_t * g, size_t size);
+extern void *agrealloc(Agraph_t * g, void *ptr, size_t oldsize,
+		       size_t size);
+extern void agfree(Agraph_t * g, void *ptr);
+extern struct _vmalloc_s *agheap(Agraph_t * g);
+
+/* an engineering compromise is a joy forever */
+extern void aginternalmapclearlocalnames(Agraph_t * g);
+
+#define agnew(g,t)		((t*)agalloc(g,sizeof(t)))
+#define agnnew(g,n,t)	((t*)agalloc(g,(n)*sizeof(t)))
+
+/* error handling */
+typedef enum { AGWARN, AGERR, AGMAX, AGPREV } agerrlevel_t;
+extern agerrlevel_t agerrno;
+extern void agseterr(agerrlevel_t);
+extern char *aglasterr(void);
+extern int agerr(agerrlevel_t level, char *fmt, ...);
+extern void agerrorf(char *fmt, ...);
+extern void agwarningf(char *fmt, ...);
+extern int agerrors(void);
+
+/* data access macros */
+/* this assumes that e[0] is out and e[1] is inedge, see edgepair in edge.c  */
+#define AGIN2OUT(e)		((e)-1)
+#define AGOUT2IN(e)		((e)+1)
+#define AGOPP(e)		((AGTYPE(e)==AGINEDGE)?AGIN2OUT(e):AGOUT2IN(e))
+#define AGMKOUT(e)		(AGTYPE(e) == AGOUTEDGE? (e): AGIN2OUT(e))
+#define AGMKIN(e)		(AGTYPE(e) == AGINEDGE?  (e): AGOUT2IN(e))
+#define AGTAIL(e)		(AGMKIN(e)->node)
+#define AGHEAD(e)		(AGMKOUT(e)->node)
+#define agtail(e)		AGTAIL(e)
+#define aghead(e)		AGHEAD(e)
+#define agopp(e)		AGOPP(e)
+
+#define TAILPORT_ID		"tailport"
+#define HEADPORT_ID		"headport"
+
+#if _PACKAGE_ast
+#   if !defined(_BLD_cgraph) && defined(__IMPORT__)
+#	define extern  __IMPORT__
+#   endif
+#endif
+#if !defined(_BLD_cgraph) && defined(GVDLL)
+#define extern  __declspec(dllimport)
+#endif
+
+extern Agdesc_t Agdirected, Agstrictdirected, Agundirected,
+    Agstrictundirected;
+
+#undef extern
+
+/* fast graphs */
+void agflatten(Agraph_t * g, int flag);
+typedef Agsubnode_t	Agnoderef_t;
+typedef Dtlink_t	Agedgeref_t;
+
+#define AGHEADPOINTER(g)	((Agnoderef_t*)(g->n_seq->data->hh._head))
+#define AGRIGHTPOINTER(rep)  	((Agnoderef_t*)((rep)->seq_link.right?((void*)((rep)->seq_link.right) - offsetof(Agsubnode_t,seq_link)):0))
+#define AGLEFTPOINTER(rep)  	((Agnoderef_t*)((rep)->seq_link.hl._left?((void*)((rep)->seq_link.hl._left) - offsetof(Agsubnode_t,seq_link)):0))
+
+#define FIRSTNREF(g)	(agflatten(g,1), AGHEADPOINTER(g))
+
+#define NEXTNREF(g,rep)  	(AGRIGHTPOINTER(rep) == AGHEADPOINTER(g)?0:AGRIGHTPOINTER(rep))
+
+#define PREVNREF(g,rep)  	(((rep)==AGHEADPOINTER(g))?0:(AGLEFTPOINTER(rep)))
+
+#define LASTNREF(g)		(agflatten(g,1), AGHEADPOINTER(g)?AGLEFTPOINTER(AGHEADPOINTER(g)):0)
+#define NODEOF(rep)		((rep)->node)
+
+#define FIRSTOUTREF(g,sn)	(agflatten(g,1), (sn)->out_seq)
+#define LASTOUTREF(g,sn)	(agflatten(g,1), (Agedgeref_t*)dtlast(sn->out_seq))
+#define FIRSTINREF(g,sn)	(agflatten(g,1), (sn)->in_seq)
+#define NEXTEREF(g,rep)  	((rep)->right)
+#define PREVEREF(g,rep)  	((rep)->hl._left)
+/* this is expedient but a bit slimey because it "knows" that dict entries of both nodes
+and edges are embedded in main graph objects but allocated separately in subgraphs */
+#define AGSNMAIN(sn)        ((sn)==(&((sn)->node->mainsub)))
+#define EDGEOF(sn,rep)		(AGSNMAIN(sn)?((Agedge_t*)((unsigned char*)(rep) - offsetof(Agedge_t,seq_link))) : ((Dthold_t*)(rep))->obj)
+
+#undef extern
+#if _PACKAGE_ast
+_END_EXTERNS_
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/color.h b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/color.h
new file mode 100644
index 0000000..cb024d9
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/color.h
@@ -0,0 +1,57 @@
+/* $Id: color.h,v 1.5 2006/12/07 23:42:18 erg Exp $ $Revision: 1.5 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+#ifndef GV_COLOR_H
+#define GV_COLOR_H
+
+/* #include "arith.h" */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct hsvrgbacolor_t {
+    char *name;
+    unsigned char h, s, v;
+    unsigned char r, g, b, a;
+} hsvrgbacolor_t;
+
+/* possible representations of color in gvcolor_t */
+typedef enum { HSVA_DOUBLE, RGBA_BYTE, RGBA_WORD, CMYK_BYTE,
+		RGBA_DOUBLE, COLOR_STRING, COLOR_INDEX } color_type_t;
+
+/* gvcolor_t can hold a color spec in a choice or representations */
+typedef struct color_s {
+    union {
+	double RGBA[4];
+	double HSVA[4];
+	unsigned char rgba[4];
+	unsigned char cmyk[4];
+	int rrggbbaa[4];
+	char *string;
+	int index;
+    } u;
+    color_type_t type;
+} gvcolor_t;
+
+#define COLOR_MALLOC_FAIL -1
+#define COLOR_UNKNOWN 1
+#define COLOR_OK 0
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/demand_loading.c b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/demand_loading.c
new file mode 100644
index 0000000..884e6ee
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/demand_loading.c
@@ -0,0 +1,17 @@
+/* $Id: demand_loading.c,v 1.2 2006/12/07 22:49:36 erg Exp $ $Revision: 1.2 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+const int Demand_Loading = 1;
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/dot_builtins.c b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/dot_builtins.c
new file mode 100644
index 0000000..249bff5
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/dot_builtins.c
@@ -0,0 +1,101 @@
+/* $Id: dot_builtins.c,v 1.10 2007/05/30 22:28:27 erg Exp $ $Revision: 1.10 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "gvplugin.h"
+
+#if defined(GVDLL) && !defined(ENABLE_LTDL)
+#define extern	__declspec(dllimport)
+#endif
+
+extern gvplugin_library_t gvplugin_dot_layout_LTX_library;
+extern gvplugin_library_t gvplugin_neato_layout_LTX_library;
+#ifdef HAVE_LIBGD
+extern gvplugin_library_t gvplugin_gd_LTX_library;
+#endif
+#ifdef HAVE_PANGOCAIRO
+extern gvplugin_library_t gvplugin_pango_LTX_library;
+#endif
+extern gvplugin_library_t gvplugin_core_LTX_library;
+
+#if defined(GVDLL) && !defined(ENABLE_LTDL)
+lt_symlist_t lt_preloaded_symbols[] = {
+	{ "gvplugin_dot_layout_LTX_library", 0},
+	{ "gvplugin_neato_layout_LTX_library", 0},
+#ifdef HAVE_PANGOCAIRO
+	{ "gvplugin_pango_LTX_library", 0},
+#endif
+#ifdef HAVE_LIBGD
+	{ "gvplugin_gd_LTX_library", 0},
+#endif
+	{ "gvplugin_core_LTX_library", 0},
+	{ 0, 0 }
+};
+
+static void*
+lt_lookup (const char* name) 
+{
+    void* addr = 0;
+    switch (*(name + 9)) { /* skip "gvplugin_" */
+    case 'c' :
+	addr = &gvplugin_core_LTX_library;
+	break;
+    case 'd' :
+	addr = &gvplugin_dot_layout_LTX_library;
+	break;
+#ifdef HAVE_LIBGD
+    case 'g' :
+	addr = &gvplugin_gd_LTX_library;
+	break;
+#endif
+    case 'n' :
+	addr = &gvplugin_neato_layout_LTX_library;
+	break;
+#ifdef HAVE_PANGOCAIRO
+    case 'p' :
+	addr = &gvplugin_pango_LTX_library;
+	break;
+#endif
+    }
+    return addr;
+}
+
+void
+init_lt_preloaded_symbols()
+{
+    const char* s;
+    int i;
+    for (i = 0; (s = lt_preloaded_symbols[i].name); i++) {
+	lt_preloaded_symbols[0].address = lt_lookup (s);
+    }
+}
+#else
+const lt_symlist_t lt_preloaded_symbols[] = {
+	{ "gvplugin_dot_layout_LTX_library", (void*)(&gvplugin_dot_layout_LTX_library) },
+	{ "gvplugin_neato_layout_LTX_library", (void*)(&gvplugin_neato_layout_LTX_library) },
+#ifdef HAVE_PANGOCAIRO
+	{ "gvplugin_pango_LTX_library", (void*)(&gvplugin_pango_LTX_library) },
+#endif
+#ifdef HAVE_LIBGD
+	{ "gvplugin_gd_LTX_library", (void*)(&gvplugin_gd_LTX_library) },
+#endif
+	{ "gvplugin_core_LTX_library", (void*)(&gvplugin_core_LTX_library) },
+	{ 0, 0 }
+};
+#endif
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/geom.h b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/geom.h
new file mode 100644
index 0000000..f276749
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/geom.h
@@ -0,0 +1,79 @@
+/* $Id: geom.h,v 1.10 2007/12/27 20:13:13 ellson Exp $ $Revision: 1.10 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+/* geometric types and macros (e.g. points and boxes) with application to, but
+ * no specific dependance on graphs */
+
+#ifndef GV_GEOM_H
+#define GV_GEOM_H
+
+#ifdef HAVE_CONFIG_H
+#include "arith.h"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    
+typedef struct { int x, y; } point;
+
+typedef struct pointf_s { double x, y; } pointf;
+
+/* tell pathplan/pathgeom.h */
+#define HAVE_POINTF_S
+
+typedef struct { point LL, UR; } box;
+
+typedef struct { pointf LL, UR; } boxf;
+
+#ifdef HAVE_CONFIG_H
+/* true if point p is inside box b */
+#define INSIDE(p,b)	(BETWEEN((b).LL.x,(p).x,(b).UR.x) && BETWEEN((b).LL.y,(p).y,(b).UR.y))
+/* true if boxes b0 and b1 overlap */
+#define OVERLAP(b0,b1)	(((b0).UR.x >= (b1).LL.x) && ((b1).UR.x >= (b0).LL.x) && ((b0).UR.y >= (b1).LL.y) && ((b1).UR.y >= (b0).LL.y))
+/* true if box b0 completely contains b1*/
+#define CONTAINS(b0,b1)	(((b0).UR.x >= (b1).UR.x) && ((b0).UR.y >= (b1).UR.y) && ((b0).LL.x <= (b1).LL.x) && ((b0).LL.y <= (b1).LL.y))
+
+/* expand box b as needed to enclose point p */
+#define EXPANDBP(b, p)	(b.LL.x = MIN(b.LL.x, p.x), b.LL.y = MIN(b.LL.y, p.y), b.UR.x = MAX(b.UR.x, p.x), b.UR.y = MAX(b.UR.y, p.y))
+/* expand box b0 as needed to enclose box b1 */
+#define EXPANDBB(b0, b1) (b0.LL.x = MIN(b0.LL.x, b1.LL.x), b0.LL.y = MIN(b0.LL.y, b1.LL.y), b0.UR.x = MAX(b0.UR.x, b1.UR.x), b0.UR.y = MAX(b0.UR.y, b1.UR.y))
+/* clip box b0 to fit box b1 */
+#define CLIPBB(b0, b1) (b0.LL.x = MAX(b0.LL.x, b1.LL.x), b0.LL.y = MAX(b0.LL.y, b1.LL.y), b0.UR.x = MIN(b0.UR.x, b1.UR.x), b0.UR.y = MIN(b0.UR.y, b1.UR.y))
+
+#define DIST2(p1,p2) (SQR((p1.x) - (p2.x))) + (SQR((p1.y) - (p2.y)))
+#define DIST(p1,p2) (sqrt(DIST2((p1),(p2))))
+
+#define POINTS_PER_INCH	72
+#define POINTS_PER_PC ((double)POINTS_PER_INCH / 6)
+#define POINTS_PER_CM ((double)POINTS_PER_INCH * 0.393700787)
+#define POINTS_PER_MM ((double)POINTS_PER_INCH * 0.0393700787)
+
+#define POINTS(f_inch)	(ROUND((f_inch)*POINTS_PER_INCH))
+#define PS2INCH(ps)		((ps)/(double)POINTS_PER_INCH)
+
+#define P2PF(p, pf) (pf.x = p.x, pf.y = p.y)
+#define PF2P(pf, p) (p.x = ROUND (pf.x), p.y = ROUND (pf.y))
+#define B2BF(b, bf) (bf.LL.x = b.LL.x, bf.LL.y = b.LL.y, bf.UR.x = b.UR.x, bf.UR.y = b.UR.y)
+#define BF2B(bf, b) (b.LL.x = ROUND (bf.LL.x), b.LL.y = ROUND (bf.LL.y), b.UR.x = ROUND (bf.UR.x), b.UR.y = ROUND (bf.UR.y))
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/graph.h b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/graph.h
new file mode 100644
index 0000000..f762d9e
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/graph.h
@@ -0,0 +1,222 @@
+/* $Id: graph.h,v 1.11 2008/06/09 16:57:01 erg Exp $ $Revision: 1.11 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+
+
+#ifndef _GRAPH_H
+#define _GRAPH_H 1
+
+#if _PACKAGE_ast
+#include    <ast.h>
+#else
+#include <sys/types.h>
+#include <stdlib.h>
+#endif
+#include <stdio.h>
+#include "cdt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define TAIL_ID				"tailport"
+#define HEAD_ID				"headport"
+
+    typedef struct Agraph_t Agraph_t;
+    typedef struct Agnode_t Agnode_t;
+    typedef struct Agedge_t Agedge_t;
+    typedef struct Agdict_t Agdict_t;
+    typedef struct Agsym_t Agsym_t;
+    typedef struct Agdata_t Agdata_t;
+    typedef struct Agproto_t Agproto_t;
+
+    typedef char *(*gets_f) (char *ubuf, int n, FILE * fp);
+
+#define AGFLAG_DIRECTED		(1<<0)
+#define AGFLAG_STRICT		(1<<1)
+#define AGFLAG_METAGRAPH	(1<<2)
+
+#define	AGRAPH				0
+#define	AGRAPHSTRICT		(AGRAPH | AGFLAG_STRICT)
+#define AGDIGRAPH 			AGFLAG_DIRECTED
+#define AGDIGRAPHSTRICT		(AGDIGRAPH | AGFLAG_STRICT)
+#define AGMETAGRAPH			(AGFLAG_DIRECTED | AGFLAG_STRICT | AGFLAG_METAGRAPH)
+
+#define AG_IS_DIRECTED(g)	((g)->kind & AGFLAG_DIRECTED)
+#define AG_IS_STRICT(g)		((g)->kind & AGFLAG_STRICT)
+#define AG_IS_METAGRAPH(g)	((g)->kind & AGFLAG_METAGRAPH)
+#define aginit()			aginitlib(sizeof(Agraph_t),sizeof(Agnode_t),sizeof(Agedge_t))
+
+    struct Agraph_t {
+	int tag:4;
+	int kind:4;
+	int handle:24;
+	char **attr;
+	char *didset;
+	char *name;
+	Agdata_t *univ;
+	Dict_t *nodes, *inedges, *outedges;
+	Agraph_t *root;
+	Agnode_t *meta_node;
+	Agproto_t *proto;
+	Agraphinfo_t u;
+    };
+
+    struct Agnode_t {
+	int tag:4;
+	int pad:4;
+	int handle:24;
+	char **attr;
+	char *didset;
+	char *name;
+	int id;
+	Agraph_t *graph;
+	Agnodeinfo_t u;
+    };
+
+    struct Agedge_t {
+	int tag:4;
+	int printkey:4;
+	int handle:24;
+	char **attr;
+	char *didset;
+	Agnode_t *head, *tail;
+	int id;
+	Agedgeinfo_t u;
+    };
+
+    struct Agdata_t {		/* for main graph */
+	Dict_t *node_dict;
+	Agdict_t *nodeattr;
+	Agdict_t *edgeattr;
+	Agdict_t *globattr;
+	int max_node_id, max_edge_id;
+    };
+
+    struct Agsym_t {
+	char *name, *value;
+	int index;
+	unsigned char printed;
+	unsigned char fixed;
+    };
+
+    struct Agdict_t {
+	char *name;
+	Dict_t *dict;
+	Agsym_t **list;
+    };
+
+    struct Agproto_t {
+	Agnode_t *n;
+	Agedge_t *e;
+	Agproto_t *prev;
+    };
+
+#if _PACKAGE_ast
+     _BEGIN_EXTERNS_		/* public data */
+#if _BLD_graph && defined(__EXPORT__)
+#define extern  __EXPORT__
+#endif
+#if !_BLD_graph && defined(__IMPORT__) && 0
+#define extern  __IMPORT__
+#endif
+#endif
+    extern char *agstrcanon(char *, char *);
+    extern char *agcanonical(char *);
+    extern char *agcanon(char *);
+    extern int aghtmlstr(char *s);
+    extern char *agget(void *, char *);
+    extern char *agxget(void *, int);
+    extern int agset(void *, char *, char *);
+    extern int agsafeset(void *, char *, char *, char*);
+    extern int agxset(void *, int, char *);
+    extern int agindex(void *, char *);
+
+    extern void aginitlib(int, int, int);
+    extern Agraph_t *agopen(char *, int);
+    extern Agraph_t *agsubg(Agraph_t *, char *);
+    extern Agraph_t *agfindsubg(Agraph_t *, char *);
+    extern void agclose(Agraph_t *);
+    extern Agraph_t *agread(FILE *);
+    extern Agraph_t *agread_usergets(FILE *, gets_f);
+    extern void agreadline(int);
+    extern void agsetfile(char *);
+    extern Agraph_t *agmemread(char *);
+    extern int agwrite(Agraph_t *, FILE *);
+    extern int agerrors(void);
+    extern Agraph_t *agprotograph(void);
+    extern Agnode_t *agprotonode(Agraph_t *);
+    extern Agedge_t *agprotoedge(Agraph_t *);
+    extern Agraph_t *agusergraph(Agnode_t *);
+    extern int agnnodes(Agraph_t *);
+    extern int agnedges(Agraph_t *);
+
+    extern void aginsert(Agraph_t *, void *);
+    extern void agdelete(Agraph_t *, void *);
+    extern int agcontains(Agraph_t *, void *);
+
+    extern Agnode_t *agnode(Agraph_t *, char *);
+    extern Agnode_t *agfindnode(Agraph_t *, char *);
+    extern Agnode_t *agfstnode(Agraph_t *);
+    extern Agnode_t *agnxtnode(Agraph_t *, Agnode_t *);
+    extern Agnode_t *aglstnode(Agraph_t *);
+    extern Agnode_t *agprvnode(Agraph_t *, Agnode_t *);
+
+    extern Agedge_t *agedge(Agraph_t *, Agnode_t *, Agnode_t *);
+    extern Agedge_t *agfindedge(Agraph_t *, Agnode_t *, Agnode_t *);
+    extern Agedge_t *agfstedge(Agraph_t *, Agnode_t *);
+    extern Agedge_t *agnxtedge(Agraph_t *, Agedge_t *, Agnode_t *);
+    extern Agedge_t *agfstin(Agraph_t *, Agnode_t *);
+    extern Agedge_t *agnxtin(Agraph_t *, Agedge_t *);
+    extern Agedge_t *agfstout(Agraph_t *, Agnode_t *);
+    extern Agedge_t *agnxtout(Agraph_t *, Agedge_t *);
+
+    extern Agsym_t *agattr(void *, char *, char *);
+    extern Agsym_t *agraphattr(Agraph_t *, char *, char *);
+    extern Agsym_t *agnodeattr(Agraph_t *, char *, char *);
+    extern Agsym_t *agedgeattr(Agraph_t *, char *, char *);
+    extern Agsym_t *agfindattr(void *, char *);
+    extern Agsym_t *agfstattr(void *);
+    extern Agsym_t *agnxtattr(void *, Agsym_t *);
+    extern Agsym_t *aglstattr(void *);
+    extern Agsym_t *agprvattr(void *, Agsym_t *);
+    extern int      agcopyattr(void *, void *);	
+
+    typedef enum { AGWARN, AGERR, AGMAX, AGPREV } agerrlevel_t;
+    extern agerrlevel_t agerrno;
+    extern void agseterr(agerrlevel_t);
+    extern char *aglasterr(void);
+    extern int agerr(agerrlevel_t level, char *fmt, ...);
+    extern void agerrorf(char *fmt, ...);
+    extern void agwarningf(char *fmt, ...);
+
+    extern char *agstrdup(char *);
+    extern char *agstrdup_html(char *s);
+    extern void agstrfree(char *);
+
+    typedef enum { AGNODE = 1, AGEDGE, AGGRAPH } agobjkind_t;
+#define agobjkind(p)		((agobjkind_t)(((Agraph_t*)(p))->tag))
+
+#define agmetanode(g)		((g)->meta_node)
+
+#undef extern
+#if _PACKAGE_ast
+     _END_EXTERNS_
+#endif
+#ifdef __cplusplus
+}
+#endif
+#endif				/* _GRAPH_H */
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gv.cpp b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gv.cpp
new file mode 100644
index 0000000..3ffebaa
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gv.cpp
@@ -0,0 +1,936 @@
+/* $Id: gv.cpp,v 1.47 2008/04/27 21:48:34 ellson Exp $ $Revision: 1.47 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+#include <string.h>
+#include "gvc.h"
+
+extern void gv_binding_init(GVC_t *gvc);
+static char emptystring[] = {'\0'};
+
+static GVC_t *gvc;
+
+static void gv_init(void) {
+    gvc = gvContext();
+    gv_binding_init(gvc);
+}
+
+Agraph_t *graph(char *name)
+{
+    if (!gvc)
+        gv_init();
+    return agopen(name, AGRAPH);
+}
+
+Agraph_t *digraph(char *name)
+{
+    if (!gvc)
+        gv_init();
+    return agopen(name, AGDIGRAPH);
+}
+
+Agraph_t *strictgraph(char *name)
+{
+    if (!gvc)
+        gv_init();
+    return agopen(name, AGRAPHSTRICT);
+}
+
+Agraph_t *strictdigraph(char *name)
+{
+    if (!gvc)
+        gv_init();
+    return agopen(name, AGDIGRAPHSTRICT);
+}
+
+Agraph_t *readstring(char *string)
+{
+    if (!gvc)
+        gv_init();
+    return agmemread(string);
+}
+
+Agraph_t *read(FILE *f)
+{
+    if (!gvc)
+        gv_init();
+    return agread(f);
+}
+
+Agraph_t *read(char *filename)
+{
+    FILE *f;
+    Agraph_t *g;
+
+    f = fopen(filename, "r");
+    if (!f)
+        return NULL;
+    if (!gvc)
+        gv_init();
+    g = agread(f);
+    fclose(f);
+    return g;
+}
+
+//-------------------------------------------------
+Agraph_t *graph(Agraph_t *g, char *name)
+{
+    if (!gvc)
+        gv_init();
+    return agsubg(g, name);
+}
+
+Agnode_t *node(Agraph_t *g, char *name)
+{
+    // creating a protonode is not permitted
+    if (!gvc || (name[0] == '\001' && strcmp (name, "\001proto") == 0))
+        return NULL;
+    return agnode(g, name);
+}
+
+Agedge_t *edge(Agnode_t *t, Agnode_t *h)
+{
+    // edges from/to the protonode are not permitted
+    if (!gvc || !t || !h
+      || (t->name[0] == '\001' && strcmp (t->name, "\001proto") == 0)
+      || (h->name[0] == '\001' && strcmp (h->name, "\001proto") == 0))
+        return NULL;
+    return agedge(t->graph, t, h);
+}
+
+// induce tail if necessary
+Agedge_t *edge(char *tname, Agnode_t *h)
+{
+    return edge(node(h->graph, tname), h);
+}
+
+// induce head if necessary
+Agedge_t *edge(Agnode_t *t, char *hname)
+{
+    return edge(t, node(t->graph, hname));
+}
+
+// induce tail/head if necessary
+Agedge_t *edge(Agraph_t *g, char *tname, char *hname)
+{
+    return edge(node(g, tname), node(g, hname));
+}
+
+//-------------------------------------------------
+static char* myagxget(void *obj, Agsym_t *a)
+{
+    int len;
+    char *val, *hs;
+
+    if (!obj || !a)
+        return emptystring;
+    val = agxget(obj, a->index);
+    if (!val)
+        return emptystring;
+    if (a->name[0] == 'l' && strcmp(a->name, "label") == 0 && aghtmlstr(val)) {
+        len = strlen(val);
+        hs = (char*)malloc(len + 3);
+        hs[0] = '<';
+        strcpy(hs+1, val);
+        hs[len+1] = '>';
+        hs[len+2] = '\0';
+        return hs;
+    }
+    return val;
+}
+char *getv(Agraph_t *g, Agsym_t *a)
+{
+    return myagxget(g, a);
+}
+char *getv(Agraph_t *g, char *attr)
+{
+    Agsym_t *a;
+
+    if (!g || !attr)
+        return NULL;
+    a = agfindattr(g->root, attr);
+    return myagxget(g, a);
+}
+static void myagxset(void *obj, Agsym_t *a, char *val)
+{
+    int len;
+    char *hs;
+
+    if (a->name[0] == 'l' && val[0] == '<' && strcmp(a->name, "label") == 0) {
+        len = strlen(val);
+        if (val[len-1] == '>') {
+            hs = strdup(val+1);
+                *(hs+len-2) = '\0';
+            val = agstrdup_html(hs);
+            free(hs);
+        }
+    }
+    agxset(obj, a->index, val);
+}
+char *setv(Agraph_t *g, Agsym_t *a, char *val)
+{
+    if (!g || !a || !val)
+        return NULL;
+    myagxset(g, a, val);
+    return val;
+}
+char *setv(Agraph_t *g, char *attr, char *val)
+{
+    Agsym_t *a;
+
+    if (!g || !attr || !val)
+        return NULL;
+    a = agfindattr(g->root, attr);
+    if (!a)
+        a = agraphattr(g->root, attr, emptystring);
+    myagxset(g, a, val);
+    return val;
+}
+//-------------------------------------------------
+char *getv(Agnode_t *n, Agsym_t *a)
+{
+    return myagxget(n, a);
+}
+char *getv(Agnode_t *n, char *attr)
+{
+    Agraph_t *g;
+    Agsym_t *a;
+
+    if (!n || !attr)
+        return NULL;
+    g = n->graph->root;
+    a = agfindattr(g->proto->n, attr);
+    return myagxget(n, a);
+}
+char *setv(Agnode_t *n, Agsym_t *a, char *val)
+{
+    if (!n || !a || !val)
+        return NULL;
+    myagxset(n, a, val);
+    return val;
+}
+char *setv(Agnode_t *n, char *attr, char *val)
+{
+    Agraph_t *g;
+    Agsym_t *a;
+
+    if (!n || !attr || !val)
+        return NULL;
+    g = n->graph->root;
+    a = agfindattr(g->proto->n, attr);
+    if (!a)
+        a = agnodeattr(g, attr, emptystring);
+    myagxset(n, a, val);
+    return val;
+}
+//-------------------------------------------------
+char *getv(Agedge_t *e, Agsym_t *a)
+{
+    return myagxget(e, a);
+}
+char *getv(Agedge_t *e, char *attr)
+{
+    Agraph_t *g;
+    Agsym_t *a;
+
+    if (!e || !attr)
+        return NULL;
+    g = e->tail->graph;
+    a = agfindattr(g->proto->e, attr);
+    return myagxget(e, a);
+}
+char *setv(Agedge_t *e, Agsym_t *a, char *val)
+{
+    if (!e || !a || !val)
+        return NULL;
+    myagxset(e, a, val);
+    return val;
+}
+char *setv(Agedge_t *e, char *attr, char *val)
+{
+    Agraph_t *g;
+    Agsym_t *a;
+
+    if (!e || !attr || !val)
+        return NULL;
+    g = e->tail->graph->root;
+    a = agfindattr(g->proto->e, attr);
+    if (!a)
+        a = agedgeattr(g, attr, emptystring);
+    myagxset(e, a, val);
+    return val;
+}
+//-------------------------------------------------
+Agraph_t *findsubg(Agraph_t *g, char *name)
+{
+    if (!g || !name)
+        return NULL;
+    return agfindsubg(g, name);
+}
+
+Agnode_t *findnode(Agraph_t *g, char *name)
+{
+    if (!g || !name)
+        return NULL;
+    return agfindnode(g, name);
+}
+
+Agedge_t *findedge(Agnode_t *t, Agnode_t *h)
+{
+    if (!t || !h)
+        return NULL;
+    return agfindedge(t->graph, t, h);
+}
+
+Agsym_t *findattr(Agraph_t *g, char *name)
+{
+    if (!g || !name)
+        return NULL;
+    return agfindattr(g, name);
+}
+
+Agsym_t *findattr(Agnode_t *n, char *name)
+{
+    if (!n || !name)
+        return NULL;
+    return agfindattr(n, name);
+}
+
+Agsym_t *findattr(Agedge_t *e, char *name)
+{
+    if (!e || !name)
+        return NULL;
+    return agfindattr(e, name);
+}
+
+//-------------------------------------------------
+
+Agnode_t *headof(Agedge_t *e)
+{
+    if (!e)
+        return NULL;
+    return e->head;
+}
+
+Agnode_t *tailof(Agedge_t *e)
+{
+    if (!e)
+        return NULL;
+    return e->tail;
+}
+
+Agraph_t *graphof(Agraph_t *g)
+{
+    if (!g || g == g->root)
+        return NULL;
+    return g->root;
+}
+
+Agraph_t *graphof(Agedge_t *e)
+{
+    if (!e)
+        return NULL;
+    return e->tail->graph;
+}
+
+Agraph_t *graphof(Agnode_t *n)
+{
+    if (!n)
+        return NULL;
+    return n->graph;
+}
+
+Agraph_t *rootof(Agraph_t *g)
+{
+    if (!g)
+        return NULL;
+    return g->root;
+}
+
+//-------------------------------------------------
+Agnode_t *protonode(Agraph_t *g)
+{
+    if (!g)
+        return NULL;
+    return g->proto->n;
+}
+
+Agedge_t *protoedge(Agraph_t *g)
+{
+    if (!g)
+        return NULL;
+    return g->proto->e;
+}
+
+//-------------------------------------------------
+char *nameof(Agraph_t *g)
+{
+    if (!g)
+        return NULL;
+    return g->name;
+}
+char *nameof(Agnode_t *n)
+{
+    if (!n)
+        return NULL;
+    return n->name;
+}
+//char *nameof(Agedge_t *e)
+//{
+//    if (!e)
+//        return NULL;
+//    return e->name;
+//}
+char *nameof(Agsym_t *a)
+{
+    if (!a)
+        return NULL;
+    return a->name;
+}
+
+//-------------------------------------------------
+bool ok(Agraph_t *g)
+{
+    if (!g) 
+        return false;
+    return true;
+}
+bool ok(Agnode_t *n)
+{
+    if (!n) 
+        return false;
+    return true;
+}
+bool ok(Agedge_t *e)
+{
+    if (!e) 
+        return false;
+    return true;
+}
+bool ok(Agsym_t *a)
+{
+    if (!a) 
+        return false;
+    return true;
+}
+//-------------------------------------------------
+Agraph_t *firstsubg(Agraph_t *g)
+{
+    Agraph_t *mg;
+    Agnode_t *n;
+    Agedge_t *e;
+
+    if (!g)
+        return NULL;
+    n = g->meta_node;
+    if (!n) 
+        return NULL;
+    mg = n->graph;
+    if (!mg) 
+        return NULL;
+    e = agfstout(mg, n);
+    if (!e) 
+        return NULL;
+    return agusergraph(e->head);
+}
+
+Agraph_t *nextsubg(Agraph_t *g, Agraph_t *sg)
+{
+    Agraph_t *mg;
+    Agnode_t *ng, *nsg;
+    Agedge_t *e;
+
+    if (!g || !sg)
+        return NULL;
+    ng = g->meta_node;
+    nsg = sg->meta_node;
+    if (!ng || !nsg) 
+        return NULL;
+    mg = ng->graph;
+    if (!mg) 
+        return NULL;
+    e = agfindedge(mg, ng, nsg);
+    if (!e) 
+        return NULL;
+    e = agnxtout(mg, e);
+    if (!e) 
+        return NULL;
+    return agusergraph(e->head);
+}
+
+Agraph_t *firstsupg(Agraph_t *g)
+{
+    Agraph_t *mg;
+    Agnode_t *n;
+    Agedge_t *e;
+
+    if (!g)
+        return NULL;
+    n = g->meta_node;
+    if (!n) 
+        return NULL;
+    mg = n->graph;
+    if (!mg) 
+        return NULL;
+    e = agfstin(mg, n);
+    if (!e) 
+        return NULL;
+    return agusergraph(e->tail);
+}
+
+Agraph_t *nextsupg(Agraph_t *g, Agraph_t *sg)
+{
+    Agraph_t *mg;
+    Agnode_t *ng, *nsg;
+    Agedge_t *e;
+
+    if (!g || !sg)
+        return NULL;
+    ng = g->meta_node;
+    nsg = sg->meta_node;
+    if (!ng || !nsg) 
+        return NULL;
+    mg = ng->graph;
+    if (!mg) 
+        return NULL;
+    e = agfindedge(mg, nsg, ng);
+    if (!e) 
+        return NULL;
+    e = agnxtin(mg, e);
+    if (!e) 
+        return NULL;
+    return agusergraph(e->tail);
+}
+
+Agedge_t *firstout(Agraph_t *g)
+{
+    Agnode_t *n;
+
+    if (!g)
+        return NULL;
+    n = agfstnode(g);
+    if (!n)
+        return NULL;
+    return agfstout(g, n);
+}
+
+Agedge_t *nextout(Agraph_t *g, Agedge_t *e)
+{
+    Agnode_t *n;
+    Agedge_t *ne;
+
+    if (!g || !e)
+        return NULL;
+    ne = agnxtout(g, e);
+    if (ne)
+        return (ne);
+    n = agnxtnode(g, e->tail);
+    if (!n)
+        return NULL;
+    return agfstout(g, n);
+}
+
+Agedge_t *firstedge(Agraph_t *g)
+{
+    if (!g)
+        return NULL;
+    return firstout(g);
+} 
+
+Agedge_t *nextedge(Agraph_t *g, Agedge_t *e)
+{
+    if (!g || !e)
+        return NULL;
+    return nextout(g, e);
+} 
+
+Agedge_t *firstout(Agnode_t *n)
+{
+    if (!n)
+        return NULL;
+    return agfstout(n->graph, n);
+}
+
+Agedge_t *nextout(Agnode_t *n, Agedge_t *e)
+{
+    if (!n || !e)
+        return NULL;
+    return agnxtout(n->graph, e);
+}
+
+Agnode_t *firsthead(Agnode_t *n)
+{
+    Agedge_t *e;
+
+    if (!n)
+        return NULL;
+    e = agfstout(n->graph, n);
+    if (!e)
+        return NULL;
+    return e->head;
+}
+
+Agnode_t *nexthead(Agnode_t *n, Agnode_t *h)
+{
+    Agedge_t *e;
+
+    if (!n || !h)
+        return NULL;
+    e = agfindedge(n->graph, n, h);
+    if (!e)
+        return NULL;
+    do {
+        e = agnxtout(n->graph, e);
+        if (!e)
+            return NULL;
+    } while (e->head == h);
+    return e->head;
+}
+
+Agedge_t *firstedge(Agnode_t *n)
+{
+    if (!n)
+        return NULL;
+    return agfstedge(n->graph, n);
+} 
+
+Agedge_t *nextedge(Agnode_t *n, Agedge_t *e)
+{
+    if (!n || !e)
+        return NULL;
+    return agnxtedge(n->graph, e, n); 
+} 
+
+Agedge_t *firstin(Agraph_t *g)
+{
+    Agnode_t *n;
+
+    if (!g)
+        return NULL;
+    n = agfstnode(g);
+    if (!n)
+        return NULL;
+    return agfstin(g, n);
+}
+
+Agedge_t *nextin(Agraph_t *g, Agedge_t *e)
+{
+    Agnode_t *n;
+    Agedge_t *ne;
+
+    if (!g || !e)
+        return NULL;
+    ne = agnxtin(g, e);
+    if (ne)
+        return (ne);
+    n = agnxtnode(g, e->head);
+    if (!n)
+        return NULL;
+    return agfstin(g, n);
+}
+
+Agedge_t *firstin(Agnode_t *n)
+{
+    if (!n)
+        return NULL;
+    return agfstin(n->graph, n);
+}
+
+Agedge_t *nextin(Agnode_t *n, Agedge_t *e)
+{
+    if (!n || !e)
+        return NULL;
+    return agnxtin(n->graph, e);
+}
+
+Agnode_t *firsttail(Agnode_t *n)
+{
+    Agedge_t *e;
+
+    if (!n)
+        return NULL;
+    e = agfstin(n->graph, n);
+    if (!e)
+        return NULL;
+    return e->tail;
+}
+
+Agnode_t *nexttail(Agnode_t *n, Agnode_t *t)
+{
+    Agedge_t *e;
+
+    if (!n || !t)
+        return NULL;
+    e = agfindedge(n->graph, t, n);
+    if (!e)
+        return NULL;
+    do {
+        e = agnxtout(n->graph, e);
+        if (!e)
+            return NULL;
+    } while (e->tail == t);
+    return e->tail;
+}
+
+Agnode_t *firstnode(Agraph_t *g)
+{
+    if (!g)
+        return NULL;
+    return agfstnode(g);
+}
+
+Agnode_t *nextnode(Agraph_t *g, Agnode_t *n)
+{
+    if (!g || !n)
+        return NULL;
+    return agnxtnode(g, n);
+}
+
+Agnode_t *firstnode(Agedge_t *e)
+{
+    if (!e)
+        return NULL;
+    return e->tail;
+}
+
+Agnode_t *nextnode(Agedge_t *e, Agnode_t *n)
+{
+    if (!e || n != e->tail)
+        return NULL;
+    return e->head;
+}
+
+Agsym_t *firstattr(Agraph_t *g)
+{
+    if (!g)
+        return NULL;
+    g = g->root;
+    if (dtsize(g->univ->globattr->dict) == 0)
+        return NULL;
+    return g->univ->globattr->list[0];
+}
+
+Agsym_t *nextattr(Agraph_t *g, Agsym_t *a)
+{
+    int i;
+
+    if (!g || !a)
+        return NULL;
+    g = g->root;
+    for (i = 0; i < dtsize(g->univ->globattr->dict); i++)
+        if (a == g->univ->globattr->list[i])
+            break;
+    i++;
+    if (i > dtsize(g->univ->globattr->dict))
+        return NULL;
+    return g->univ->globattr->list[i];
+}
+
+Agsym_t *firstattr(Agnode_t *n)
+{
+    Agraph_t *g;
+
+    if (!n)
+        return NULL;
+    g = n->graph;
+    if (dtsize(g->univ->nodeattr->dict) == 0)
+        return NULL;
+    return g->univ->nodeattr->list[0];
+}
+
+Agsym_t *nextattr(Agnode_t *n, Agsym_t *a)
+{
+    Agraph_t *g;
+    int i;
+
+    if (!n || !a)
+        return NULL;
+    g = n->graph;
+    for (i = 0; i < dtsize(g->univ->nodeattr->dict); i++)
+        if (a == g->univ->nodeattr->list[i])
+            break;
+    i++;
+    if (i > dtsize(g->univ->nodeattr->dict))
+        return NULL;
+    return g->univ->nodeattr->list[i];
+}
+
+Agsym_t *firstattr(Agedge_t *e)
+{
+    Agraph_t *g;
+
+    if (!e)
+        return NULL;
+    g = e->tail->graph;
+    if (dtsize(g->univ->edgeattr->dict) == 0)
+        return NULL;
+    return g->univ->edgeattr->list[0];
+}
+
+Agsym_t *nextattr(Agedge_t *e, Agsym_t *a)
+{
+    Agraph_t *g;
+    int i;
+
+    if (!e || !a)
+        return NULL;
+    g = e->tail->graph;
+    for (i = 0; i < dtsize(g->univ->edgeattr->dict); i++)
+        if (a == g->univ->edgeattr->list[i])
+            break;
+    i++;
+    if (i > dtsize(g->univ->edgeattr->dict))
+        return NULL;
+    return g->univ->edgeattr->list[i];
+}
+
+bool rm(Agraph_t *g)
+{
+    Agedge_t *e;
+
+    if (!g)
+        return false;
+    if (g->meta_node) {
+        for (e = agfstout(g->meta_node->graph, g->meta_node); e;
+        		e = agnxtout(g->meta_node->graph, e)) {
+            rm(agusergraph(e->head));
+        }
+        if (g == g->root) {
+            agclose(g);
+        } else {
+            agdelete(g->meta_node->graph, g->meta_node);
+        }
+        return true;
+    }
+    fprintf(stderr, "subgraph has no meta_node\n");
+    return false;
+}
+
+bool rm(Agnode_t *n)
+{
+    if (!n)
+        return false;
+    // removal of the protonode is not permitted
+    if (n->name[0] == '\001' && strcmp (n->name, "\001proto") ==0)
+        return false;
+    agdelete(n->graph, n);
+    return true;
+}
+
+bool rm(Agedge_t *e)
+{
+    if (!e)
+        return false;
+    // removal of the protoedge is not permitted
+    if ((e->head->name[0] == '\001' && strcmp (e->head->name, "\001proto") == 0)
+     || (e->tail->name[0] == '\001' && strcmp (e->tail->name, "\001proto") == 0))
+        return false;
+    agdelete(e->head->graph->root, e);
+    return true;
+}
+
+bool layout(Agraph_t *g, char *engine)
+{
+    int err;
+
+    if (!g)
+        return false;
+    err = gvFreeLayout(gvc, g);  /* ignore errors */
+    err = gvLayout(gvc, g, engine);
+    return (! err);
+}
+
+// annotate the graph with layout information
+bool render(Agraph_t *g)
+{
+    if (!g)
+        return false;
+    attach_attrs(g);
+    return true;
+}
+
+// render to a filename
+bool render(Agraph_t *g, char *format, char *filename)
+{
+    int err;
+
+    if (!g)
+        return false;
+    err = gvRenderFilename(gvc, g, format, filename);
+    return (! err);
+}
+
+// render to stdout
+bool render(Agraph_t *g, char *format)
+{
+    int err;
+
+    if (!g)
+        return false;
+    err = gvRender(gvc, g, format, stdout);
+    return (! err);
+}
+
+// render to a FILE
+bool render(Agraph_t *g, char *format, FILE *f)
+{
+    int err;
+
+    if (!g)
+        return false;
+    err = gvRender(gvc, g, format, f);
+    return (! err);
+}
+
+ // render to a data string
+char* renderdata(Agraph_t *g, char *format)
+{
+    int err;
+    char *data;
+    unsigned int length;
+ 
+    if (!g)
+        return NULL;
+    err = gvRenderData(gvc, g, format, &data, &length);
+    if (err)
+	return NULL;
+    data = (char*)realloc(data, length + 1);
+    return data;
+}
+
+bool write(Agraph_t *g, FILE *f)
+{
+    int err;
+
+    if (!g)
+        return false;
+    err = agwrite(g, f);
+    return (! err);
+}
+
+bool write(Agraph_t *g, char *filename)
+{
+    FILE *f;
+    int err;
+
+    if (!g)
+        return false;
+    f = fopen(filename, "w");
+    if (!f)
+        return false;
+    err = agwrite(g, f);
+    fclose(f);
+    return (! err);
+}
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gv.i b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gv.i
new file mode 100644
index 0000000..3c11f3e
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gv.i
@@ -0,0 +1,388 @@
+/* $Id: gv.i,v 1.35 2008/06/13 13:39:04 ellson Exp $ $Revision: 1.35 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+%module gv
+%{
+
+/* some language headers (e.g. php.h, ruby.h) leave these defined */
+#undef PACKAGE_BUGREPORT
+#undef PACKAGE_STRING
+#undef PACKAGE_TARNAME
+#undef PACKAGE_VERSION
+#undef PACKAGE_NAME
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include "gvc.h"
+
+/** New graphs */
+/*** New empty graph */
+extern Agraph_t *graph(char *name);
+extern Agraph_t *digraph(char *name);
+extern Agraph_t *strictgraph(char *name);
+extern Agraph_t *strictdigraph(char *name);
+/*** New graph from a dot-syntax string or file */
+extern Agraph_t *readstring(char *string);
+extern Agraph_t *read(char *filename);
+extern Agraph_t *read(FILE *f);	
+/*** Add new subgraph to existing graph */
+extern Agraph_t *graph(Agraph_t *g, char *name);
+
+/** New nodes */
+/*** Add new node to existing graph */
+extern Agnode_t *node(Agraph_t *g, char *name);
+
+/** New edges */
+/*** Add new edge between existing nodes */
+extern Agedge_t *edge(Agnode_t *t, Agnode_t *h);
+/*** Add a new edge between an existing tail node, and a named head node which will be induced in the graph if it doesn't already exist */
+extern Agedge_t *edge(Agnode_t *t, char *hname);
+/*** Add a new edge between an existing head node, and a named tail node which will be induced in the graph if it doesn't already exist */
+extern Agedge_t *edge(char *tname, Agnode_t *h);
+/*** Add a new edge between named tail  and head nodes which will be induced in the graph if they don't already exist */
+extern Agedge_t *edge(Agraph_t *g, char *tname, char *hname);
+
+/** Setting attribute values */
+/*** Set value of named attribute of graph/node/edge - creating attribute if necessary */
+extern char *setv(Agraph_t *g, char *attr, char *val);
+extern char *setv(Agnode_t *n, char *attr, char *val);
+extern char *setv(Agedge_t *e, char *attr, char *val);
+
+/*** Set value of existing attribute of graph/node/edge (using attribute handle) */
+extern char *setv(Agraph_t *g, Agsym_t *a, char *val);
+extern char *setv(Agnode_t *n, Agsym_t *a, char *val);
+extern char *setv(Agedge_t *e, Agsym_t *a, char *val);
+
+/** Getting attribute values */
+/*** Get value of named attribute of graph/node/edge */
+extern char *getv(Agraph_t *g, char *attr);
+extern char *getv(Agnode_t *n, char *attr);
+extern char *getv(Agedge_t *e, char *attr);
+
+/*** Get value of attribute of graph/node/edge (using attribute handle) */
+extern char *getv(Agraph_t *g, Agsym_t *a);
+extern char *getv(Agnode_t *n, Agsym_t *a);
+extern char *getv(Agedge_t *e, Agsym_t *a);
+
+/** Obtain names from handles */
+extern char *nameof(Agraph_t *g);
+extern char *nameof(Agnode_t *n);
+//extern char *nameof(Agedge_t *e);
+extern char *nameof(Agsym_t *a);
+
+/** Find handles from names */
+extern Agraph_t *findsubg(Agraph_t *g, char *name);
+extern Agnode_t *findnode(Agraph_t *g, char *name);
+extern Agedge_t *findedge(Agnode_t *t, Agnode_t *h);
+
+/** */
+extern Agsym_t *findattr(Agraph_t *g, char *name);
+extern Agsym_t *findattr(Agnode_t *n, char *name);
+extern Agsym_t *findattr(Agedge_t *e, char *name);
+
+/** Misc graph navigators returning handles */
+extern Agnode_t *headof(Agedge_t *e);
+extern Agnode_t *tailof(Agedge_t *e);
+extern Agraph_t *graphof(Agraph_t *g);
+extern Agraph_t *graphof(Agedge_t *e);
+extern Agraph_t *graphof(Agnode_t *n);
+extern Agraph_t *rootof(Agraph_t *g);
+
+/** Obtain handles of proto node/edge for setting default attribute values */
+extern Agnode_t *protonode(Agraph_t *g);
+extern Agedge_t *protoedge(Agraph_t *g);
+
+/** Iterators */
+/*** Iteration termination tests */
+extern bool ok(Agraph_t *g);
+extern bool ok(Agnode_t *n);
+extern bool ok(Agedge_t *e);
+extern bool ok(Agsym_t *a);
+
+/*** Iterate over subgraphs of a graph */
+extern Agraph_t *firstsubg(Agraph_t *g);
+extern Agraph_t *nextsubg(Agraph_t *g, Agraph_t *sg);
+
+/*** Iterate over supergraphs of a graph (obscure and rarely useful) */
+extern Agraph_t *firstsupg(Agraph_t *g);
+extern Agraph_t *nextsupg(Agraph_t *g, Agraph_t *sg);
+
+/*** Iterate over edges of a graph */
+extern Agedge_t *firstedge(Agraph_t *g);
+extern Agedge_t *nextedge(Agraph_t *g, Agedge_t *e);
+
+/*** Iterate over outedges of a graph */
+extern Agedge_t *firstout(Agraph_t *g);
+extern Agedge_t *nextout(Agraph_t *g, Agedge_t *e);
+
+/*** Iterate over edges of a node */
+extern Agedge_t *firstedge(Agnode_t *n);
+extern Agedge_t *nextedge(Agnode_t *n, Agedge_t *e);
+
+/*** Iterate over out-edges of a node */
+extern Agedge_t *firstout(Agnode_t *n);
+extern Agedge_t *nextout(Agnode_t *n, Agedge_t *e);
+
+/*** Iterate over head nodes reachable from out-edges of a node */
+extern Agnode_t *firsthead(Agnode_t *n);
+extern Agnode_t *nexthead(Agnode_t *n, Agnode_t *h);
+
+/*** Iterate over in-edges of a graph */
+extern Agedge_t *firstin(Agraph_t *g);
+extern Agedge_t *nextin(Agnode_t *n, Agedge_t *e);
+
+/*** Iterate over in-edges of a node */
+extern Agedge_t *firstin(Agnode_t *n);
+extern Agedge_t *nextin(Agraph_t *g, Agedge_t *e);
+
+/*** Iterate over tail nodes reachable from in-edges of a node */
+extern Agnode_t *firsttail(Agnode_t *n);
+extern Agnode_t *nexttail(Agnode_t *n, Agnode_t *t);
+
+/*** Iterate over nodes of a graph */
+extern Agnode_t *firstnode(Agraph_t *g);
+extern Agnode_t *nextnode(Agraph_t *g, Agnode_t *n);
+
+/*** Iterate over nodes of an edge */
+extern Agnode_t *firstnode(Agedge_t *e);
+extern Agnode_t *nextnode(Agedge_t *e, Agnode_t *n);
+
+/*** Iterate over attributes of a graph */
+extern Agsym_t *firstattr(Agraph_t *g);
+extern Agsym_t *nextattr(Agraph_t *g, Agsym_t *a);
+
+/*** Iterate over attributes of an edge */
+extern Agsym_t *firstattr(Agedge_t *e);
+extern Agsym_t *nextattr(Agedge_t *e, Agsym_t *a);
+
+/*** Iterate over attributes of a node */
+extern Agsym_t *firstattr(Agnode_t *n);
+extern Agsym_t *nextattr(Agnode_t *n, Agsym_t *a);
+
+/** Remove graph objects */
+extern bool rm(Agraph_t *g);
+extern bool rm(Agnode_t *n);
+extern bool rm(Agedge_t *e);
+
+/** Layout */
+/*** Annotate a graph with layout attributes and values using a specific layout engine */
+extern bool layout(Agraph_t *g, char *engine);
+
+/** Render */
+/*** Render a layout into attributes of the graph */
+extern bool render(Agraph_t *g); 
+
+/*** Render a layout in a specific format */
+extern bool render(Agraph_t *g, char *format);
+extern bool render(Agraph_t *g, char *format, char *filename);
+extern bool render(Agraph_t *g, char *format, FILE *f);
+
+extern char* renderdata(Agraph_t *g, char *format);
+
+
+/*** Writing graph back to file */
+extern bool write(Agraph_t *g, char *filename);
+extern bool write(Agraph_t *g, FILE *f);
+
+%}
+
+%inline %{
+
+/** New graphs */
+/*** New empty graph */
+extern Agraph_t *graph(char *name);
+extern Agraph_t *digraph(char *name);
+extern Agraph_t *strictgraph(char *name);
+extern Agraph_t *strictdigraph(char *name);
+/*** New graph from a dot-syntax string or file */
+extern Agraph_t *readstring(char *string);
+extern Agraph_t *read(char *filename);
+extern Agraph_t *read(FILE *f);	
+/*** Add new subgraph to existing graph */
+extern Agraph_t *graph(Agraph_t *g, char *name);
+
+/** New nodes */
+/*** Add new node to existing graph */
+extern Agnode_t *node(Agraph_t *g, char *name);
+
+/** New edges */
+/*** Add new edge between existing nodes */
+extern Agedge_t *edge(Agnode_t *t, Agnode_t *h);
+/*** Add a new edge between an existing tail node, and a named head node which will be induced in the graph if it doesn't already exist */
+extern Agedge_t *edge(Agnode_t *t, char *hname);
+/*** Add a new edge between an existing head node, and a named tail node which will be induced in the graph if it doesn't already exist */
+extern Agedge_t *edge(char *tname, Agnode_t *h);
+/*** Add a new edge between named tail  and head nodes which will be induced in the graph if they don't already exist */
+extern Agedge_t *edge(Agraph_t *g, char *tname, char *hname);
+
+/** Setting attribute values */
+/*** Set value of named attribute of graph/node/edge - creating attribute if necessary */
+extern char *setv(Agraph_t *g, char *attr, char *val);
+extern char *setv(Agnode_t *n, char *attr, char *val);
+extern char *setv(Agedge_t *e, char *attr, char *val);
+
+/*** Set value of existing attribute of graph/node/edge (using attribute handle) */
+extern char *setv(Agraph_t *g, Agsym_t *a, char *val);
+extern char *setv(Agnode_t *n, Agsym_t *a, char *val);
+extern char *setv(Agedge_t *e, Agsym_t *a, char *val);
+
+/** Getting attribute values */
+/*** Get value of named attribute of graph/node/edge */
+extern char *getv(Agraph_t *g, char *attr);
+extern char *getv(Agnode_t *n, char *attr);
+extern char *getv(Agedge_t *e, char *attr);
+
+/*** Get value of attribute of graph/node/edge (using attribute handle) */
+extern char *getv(Agraph_t *g, Agsym_t *a);
+extern char *getv(Agnode_t *n, Agsym_t *a);
+extern char *getv(Agedge_t *e, Agsym_t *a);
+
+/** Obtain names from handles */
+extern char *nameof(Agraph_t *g);
+extern char *nameof(Agnode_t *n);
+//extern char *nameof(Agedge_t *e);
+extern char *nameof(Agsym_t *a);
+
+/** Find handles from names */
+extern Agraph_t *findsubg(Agraph_t *g, char *name);
+extern Agnode_t *findnode(Agraph_t *g, char *name);
+extern Agedge_t *findedge(Agnode_t *t, Agnode_t *h);
+
+/** */
+extern Agsym_t *findattr(Agraph_t *g, char *name);
+extern Agsym_t *findattr(Agnode_t *n, char *name);
+extern Agsym_t *findattr(Agedge_t *e, char *name);
+
+/** Misc graph navigators returning handles */
+extern Agnode_t *headof(Agedge_t *e);
+extern Agnode_t *tailof(Agedge_t *e);
+extern Agraph_t *graphof(Agraph_t *g);
+extern Agraph_t *graphof(Agedge_t *e);
+extern Agraph_t *graphof(Agnode_t *n);
+extern Agraph_t *rootof(Agraph_t *g);
+
+/** Obtain handles of proto node/edge for setting default attribute values */
+extern Agnode_t *protonode(Agraph_t *g);
+extern Agedge_t *protoedge(Agraph_t *g);
+
+/** Iterators */
+/*** Iteration termination tests */
+extern bool ok(Agraph_t *g);
+extern bool ok(Agnode_t *n);
+extern bool ok(Agedge_t *e);
+extern bool ok(Agsym_t *a);
+
+/*** Iterate over subgraphs of a graph */
+extern Agraph_t *firstsubg(Agraph_t *g);
+extern Agraph_t *nextsubg(Agraph_t *g, Agraph_t *sg);
+
+/*** Iterate over supergraphs of a graph (obscure and rarely useful) */
+extern Agraph_t *firstsupg(Agraph_t *g);
+extern Agraph_t *nextsupg(Agraph_t *g, Agraph_t *sg);
+
+/*** Iterate over edges of a graph */
+extern Agedge_t *firstedge(Agraph_t *g);
+extern Agedge_t *nextedge(Agraph_t *g, Agedge_t *e);
+
+/*** Iterate over outedges of a graph */
+extern Agedge_t *firstout(Agraph_t *g);
+extern Agedge_t *nextout(Agraph_t *g, Agedge_t *e);
+
+/*** Iterate over edges of a node */
+extern Agedge_t *firstedge(Agnode_t *n);
+extern Agedge_t *nextedge(Agnode_t *n, Agedge_t *e);
+
+/*** Iterate over out-edges of a node */
+extern Agedge_t *firstout(Agnode_t *n);
+extern Agedge_t *nextout(Agnode_t *n, Agedge_t *e);
+
+/*** Iterate over head nodes reachable from out-edges of a node */
+extern Agnode_t *firsthead(Agnode_t *n);
+extern Agnode_t *nexthead(Agnode_t *n, Agnode_t *h);
+
+/*** Iterate over in-edges of a graph */
+extern Agedge_t *firstin(Agraph_t *g);
+extern Agedge_t *nextin(Agnode_t *n, Agedge_t *e);
+
+/*** Iterate over in-edges of a node */
+extern Agedge_t *firstin(Agnode_t *n);
+extern Agedge_t *nextin(Agraph_t *g, Agedge_t *e);
+
+/*** Iterate over tail nodes reachable from in-edges of a node */
+extern Agnode_t *firsttail(Agnode_t *n);
+extern Agnode_t *nexttail(Agnode_t *n, Agnode_t *t);
+
+/*** Iterate over nodes of a graph */
+extern Agnode_t *firstnode(Agraph_t *g);
+extern Agnode_t *nextnode(Agraph_t *g, Agnode_t *n);
+
+/*** Iterate over nodes of an edge */
+extern Agnode_t *firstnode(Agedge_t *e);
+extern Agnode_t *nextnode(Agedge_t *e, Agnode_t *n);
+
+/*** Iterate over attributes of a graph */
+extern Agsym_t *firstattr(Agraph_t *g);
+extern Agsym_t *nextattr(Agraph_t *g, Agsym_t *a);
+
+/*** Iterate over attributes of an edge */
+extern Agsym_t *firstattr(Agedge_t *e);
+extern Agsym_t *nextattr(Agedge_t *e, Agsym_t *a);
+
+/*** Iterate over attributes of a node */
+extern Agsym_t *firstattr(Agnode_t *n);
+extern Agsym_t *nextattr(Agnode_t *n, Agsym_t *a);
+
+/** Remove graph objects */
+extern bool rm(Agraph_t *g);
+extern bool rm(Agnode_t *n);
+extern bool rm(Agedge_t *e);
+
+/** Layout */
+/*** Annotate a graph with layout attributes and values using a specific layout engine */
+extern bool layout(Agraph_t *g, char *engine);
+
+/** Render */
+/*** Render a layout into attributes of the graph */
+extern bool render(Agraph_t *g); 
+
+/*** Render a layout in a specific format */
+extern bool render(Agraph_t *g, char *format);
+extern bool render(Agraph_t *g, char *format, char *filename);
+extern bool render(Agraph_t *g, char *format, FILE *f);
+
+extern char* renderdata(Agraph_t *g, char *format);
+
+
+/*** Writing graph back to file */
+extern bool write(Agraph_t *g, char *filename);
+extern bool write(Agraph_t *g, FILE *f);
+
+
+#ifdef SWIGTCL
+// A typemap telling SWIG to ignore an argument for input
+// However, we still need to pass a pointer to the C function
+%typemap(in,numinputs=0) char *outdata (char *temp) {
+     $1 = &temp;
+}
+// A typemap defining how to return an argument by appending it to the result
+%typemap(argout) char *outdata {
+     Tcl_Obj *o = Tcl_NewStringObj($1);
+     Tcl_ListObjAppendElement(interp,$result,o);
+}
+#endif
+
+%}
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvc.h b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvc.h
new file mode 100644
index 0000000..4095c59
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvc.h
@@ -0,0 +1,113 @@
+/* $Id: gvc.h,v 1.40 2008/05/23 14:34:36 glenlow Exp $ $Revision: 1.40 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+ * *      This software is part of the graphviz package      *
+ * *                http://www.graphviz.org/                 *
+ * *                                                         *
+ * *            Copyright (c) 1994-2004 AT&T Corp.           *
+ * *                and is licensed under the                *
+ * *            Common Public License, Version 1.0           *
+ * *                      by AT&T Corp.                      *
+ * *                                                         *
+ * *        Information and Software Systems Research        *
+ * *              AT&T Research, Florham Park NJ             *
+ * **********************************************************/
+
+#ifndef			GVC_H
+#define			GVC_H
+
+#include "types.h"
+#include "graph.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define dotneato_initialize dotneato_initialize_DEPRECATED_BY_gvParseArgs
+#define parse_args parse_args_DEPRECATED_BY_gvParseArgs
+
+#define dot_layout dot_layout_DEPRECATED_BY_gvLayout
+#define neato_layout dot_layout_DEPRECATED_BY_gvLayout
+#define fdp_layout dot_layout_DEPRECATED_BY_gvLayout
+#define circo_layout dot_layout_DEPRECATED_BY_gvLayout
+#define twopi_layout dot_layout_DEPRECATED_BY_gvLayout
+#define gvBindContext gvBindContext_DEPRECATED_BY_gvLayout
+#define gvlayout_layout gvlayout_layout_DEPRECATED_BY_gvLayoutJobs
+
+#define emit_jobs emit_jobs_DEPRECATED_BY_gvRenderJobs
+#define dotneato_write dotneato_write_DEPRECATED_BY_gvRenderJobs
+
+#define dot_cleanup dot_cleanup_DEPRECATED_BY_gvFreeLayout
+#define neato_cleanup dot_cleanup_DEPRECATED_BY_gvFreeLayout
+#define fdp_cleanup dot_cleanup_DEPRECATED_BY_gvFreeLayout
+#define circo_cleanup dot_cleanup_DEPRECATED_BY_gvFreeLayout
+#define twopi_cleanup dot_cleanup_DEPRECATED_BY_gvFreeLayout
+#define gvlayout_cleanup gvlayout_cleanup_DEPRECATED_BY_gvFreeLayout
+
+#define gvCleanup gvCleanup_DEPRECATED_BY_gvFreeContext
+#define dotneato_terminate dotneato_terminate_DEPRECATED_BY_gvFreeContext
+#define next_input_graph next_input_graph_DEPRECATED_BY_gvNextInputGraph
+
+/* misc */
+/* FIXME - this needs eliminating or renaming */
+extern void gvToggle(int);
+
+/* set up a graphviz context */
+extern GVC_t *gvNEWcontext(char **info, char *user);
+extern char *gvUsername(void);
+
+/*  set up a graphviz context - alternative */
+/*     (wraps the above two functions using info built into libgvc) */
+extern GVC_t *gvContext(void);
+
+/* get information associated with a graphviz context */
+extern char **gvcInfo(GVC_t*);
+extern char *gvcVersion(GVC_t*);
+extern char *gvcBuildDate(GVC_t*);
+extern char *gvcUsername(GVC_t*);
+
+/* get plugins associated with a graphviz context */
+extern gvplugin_available_t *gvFirstPlugin(GVC_t *gvc, api_t api);
+extern gvplugin_available_t *gvNextPlugin(gvplugin_available_t *plugin);
+extern char *gvPluginType(gvplugin_available_t *plugin);
+
+/* parse command line args - minimally argv[0] sets layout engine */
+extern int gvParseArgs(GVC_t *gvc, int argc, char **argv);
+extern graph_t *gvNextInputGraph(GVC_t *gvc);
+
+/* Compute a layout using a specified engine */
+extern int gvLayout(GVC_t *gvc, graph_t *g, char *engine);
+
+/* Compute a layout using layout engine from command line args */
+extern int gvLayoutJobs(GVC_t *gvc, graph_t *g);
+
+/* Render layout into string attributes of the graph */
+extern void attach_attrs(graph_t *g);
+
+/* Parse an html string */
+extern char *agstrdup_html(char *s);
+extern int aghtmlstr(char *s);
+
+/* Render layout in a specified format to an open FILE */
+extern int gvRender(GVC_t *gvc, graph_t *g, char *format, FILE *out);
+
+/* Render layout in a specified format to an open FILE */
+extern int gvRenderFilename(GVC_t *gvc, graph_t *g, char *format, char *filename);
+
+/* Render layout in a specified format to a malloc'ed string */
+extern int gvRenderData(GVC_t *gvc, graph_t *g, char *format, char **result, unsigned int *length);
+
+/* Render layout according to -T and -o options found by gvParseArgs */
+extern int gvRenderJobs(GVC_t *gvc, graph_t *g);
+
+/* Clean up layout data structures - layouts are not nestable (yet) */
+extern int gvFreeLayout(GVC_t *gvc, graph_t *g);
+
+/* Clean up graphviz context */
+extern int gvFreeContext(GVC_t *gvc);
+
+#ifdef __cplusplus
+}
+#endif
+#endif			/* GVC_H */
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvcext.h b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvcext.h
new file mode 100644
index 0000000..6ec3d7c
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvcext.h
@@ -0,0 +1,83 @@
+/* $Id: gvcext.h,v 1.8 2008/05/23 14:34:36 glenlow Exp $ $Revision: 1.8 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+/* Common header used by both clients and plugins */
+
+#ifndef GVCEXT_H
+#define GVCEXT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef WITH_CODEGENS
+    typedef struct codegen_s codegen_t;
+    typedef struct codegen_info_s codegen_info_t;
+#endif
+
+/*
+ * Define an apis array of name strings using an enumerated api_t as index.
+ * The enumerated type is defined here.  The apis array is
+ * inititialized in gvplugin.c by redefining ELEM and reinvoking APIS.
+ */
+#define APIS ELEM(render) ELEM(layout) ELEM(textlayout) ELEM(device) ELEM(loadimage)
+
+/*
+ * Define api_t using names based on the plugin names with API_ prefixed.
+ */
+#define ELEM(x) API_##x,
+    typedef enum { APIS _DUMMY_ELEM_=0 } api_t; /* API_render, API_layout, ... */
+    			/* Stupid but true: The sole purpose of "_DUMMY_ELEM_=0"
+			 * is to avoid a "," after the last element of the enum
+			 * because some compilers when using "-pedantic"
+			 * generate an error for about the dangling ","
+			 * but only if this header is used from a .cpp file!
+			 * Setting it to 0 makes sure that the enumeration
+			 * does not define an extra value.  (It does however
+			 * define _DUMMY_ELEM_ as an enumeration symbol,
+			 * but its value duplicates that of the first
+			 * symbol in the enumeration - in this case "render".)
+			 */
+
+    			/* One could wonder why trailing "," in:
+			 * 	int nums[]={1,2,3,};
+			 * is OK, but in:
+			 * 	typedef enum {a,b,c,} abc_t; 
+			 * is not!!!
+			 */
+#undef ELEM
+
+    typedef struct GVJ_s GVJ_t;
+    typedef struct GVC_s GVC_t;
+
+    typedef struct {
+	const char *name;
+	void* address;
+    } lt_symlist_t;
+
+    typedef struct gvplugin_available_s gvplugin_available_t;
+
+#if defined(GVDLL) && !defined(ENABLE_LTDL)
+    extern lt_symlist_t lt_preloaded_symbols[];
+#else
+    extern const lt_symlist_t lt_preloaded_symbols[];
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvcjob.h b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvcjob.h
new file mode 100644
index 0000000..a6da5bf
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvcjob.h
@@ -0,0 +1,379 @@
+/* $Id: gvcjob.h,v 1.72 2008/03/14 22:08:40 ellson Exp $ $Revision: 1.72 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+/* Common header used by both clients and plugins */
+
+#ifndef GVCJOB_H
+#define GVCJOB_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "gvcommon.h"
+#include "color.h"
+
+#define ARRAY_SIZE(A) (sizeof(A)/sizeof(A[0]))
+
+    typedef struct gvdevice_engine_s gvdevice_engine_t;
+    typedef struct gvformatter_engine_s gvformatter_engine_t;
+    typedef struct gvrender_engine_s gvrender_engine_t;
+    typedef struct gvlayout_engine_s gvlayout_engine_t;
+    typedef struct gvtextlayout_engine_s gvtextlayout_engine_t;
+    typedef struct gvloadimage_engine_s gvloadimage_engine_t;
+
+    typedef enum { PEN_NONE, PEN_DASHED, PEN_DOTTED, PEN_SOLID } pen_type;
+    typedef enum { FILL_NONE, FILL_SOLID } fill_type;
+    typedef enum { FONT_REGULAR, FONT_BOLD, FONT_ITALIC } font_type;
+#define PENWIDTH_NORMAL 1.
+#define PENWIDTH_BOLD 2.
+    typedef enum { GVATTR_STRING, GVATTR_BOOL, GVATTR_COLOR } gvattr_t;
+
+/* The -T output formats listed below are examples only, they are not definitive or inclusive,
+ other outputs may use the flags now, or in the future 
+
+                   Default emit order is breadth first graph walk order 
+ EMIT_SORTED			emits nodes before edges		
+ EMIT_COLORS			emits colors before nodes or edge -Tfig 
+ EMIT_CLUSTERS_LAST		emits cluster after nodes and edges 	
+ EMIT_PREORDER			emit in preorder traversal ???		
+ EMIT_EDGE_SORTED		emits edges before nodes		
+
+ GVDEVICE_DOES_PAGES		provides pagination support -Tps	
+ GVDEVICE_DOES_LAYERS		provides support for layers -Tps	
+ GVDEVICE_EVENTS		supports mouse events -Tgtk, -Txlib	
+ GVDEVICE_DOES_TRUECOLOR	supports alph channel -Tpng, -Tgtk, -Txlib 
+ GVDEVICE_BINARY_FORMAT		Suppresses \r\n substitution for linends 
+ GVDEVICE_COMPRESSED_FORMAT	controls libz compression		
+ GVDEVICE_NO_WRITER		used when gvdevice is not used because device uses its own writer, -Tming, devil outputs   (FIXME seems to overlap OUTPUT_NOT_REQUIRED)
+
+ GVRENDER_Y_GOES_DOWN		device origin top left, y goes down, otherwise
+  				device origin lower left, y goes up	
+ GVRENDER_DOES_TRANSFORM	device uses scale, translate, rotate to do its own
+ 				coordinate transformations, otherwise coordinates 
+  				are pre-transformed			
+ GVRENDER_DOES_ARROWS		renderer has its own idea of arrow shapes (deprecated) 
+ GVRENDER_DOES_LABELS		basically, maps don't need labels	
+ GVRENDER_DOES_MAPS		renderer encodes mapping information for mouse events -Tcmapx -Tsvg 
+ GVRENDER_DOES_MAP_RECTANGLE	supports a 2 coord rectngle optimization 
+ GVRENDER_DOES_MAP_CIRCLE	supports a 1 coord + radius circle optimization	
+ GVRENDER_DOES_MAP_POLYGON	supports polygons (basically, -Tsvg uses anchors, so doesn't need to support any map shapes) 
+ GVRENDER_DOES_MAP_ELLIPSE	supports a 2 coord ellipse optimization	
+ GVRENDER_DOES_MAP_BSPLINE	supports mapping of splines		
+ GVRENDER_DOES_TOOLTIPS		can represent tooltip info -Tcmapx, -Tsvg		
+ GVRENDER_DOES_TARGETS		can represent target info (open link in a new tab or window) 
+ GVRENDER_DOES_Z		render support 2.5D representation -Tvrml 
+ GVRENDER_NO_BG			don't paint white background, assumes white paper -Tps 
+ LAYOUT_NOT_REQUIRED 		don't perform layout -Tcanon 		
+ OUTPUT_NOT_REQUIRED		don't use gvdevice for output (basically when agwrite() used instead) -Tcanon, -Txdot 
+ */
+
+
+#define EMIT_SORTED (1<<0)
+#define EMIT_COLORS (1<<1)
+#define EMIT_CLUSTERS_LAST (1<<2)
+#define EMIT_PREORDER (1<<3)
+#define EMIT_EDGE_SORTED (1<<4)
+#define GVDEVICE_DOES_PAGES (1<<5)
+#define GVDEVICE_DOES_LAYERS (1<<6)
+#define GVDEVICE_EVENTS (1<<7)
+#define GVDEVICE_DOES_TRUECOLOR (1<<8)
+#define GVDEVICE_BINARY_FORMAT (1<<9)
+#define GVDEVICE_COMPRESSED_FORMAT (1<<10)
+#define GVDEVICE_NO_WRITER (1<<11)
+#define GVRENDER_Y_GOES_DOWN (1<<12)
+#define GVRENDER_DOES_TRANSFORM (1<<13)
+#define GVRENDER_DOES_ARROWS (1<<14)
+#define GVRENDER_DOES_LABELS (1<<15)
+#define GVRENDER_DOES_MAPS (1<<16)
+#define GVRENDER_DOES_MAP_RECTANGLE (1<<17)
+#define GVRENDER_DOES_MAP_CIRCLE (1<<18)
+#define GVRENDER_DOES_MAP_POLYGON (1<<19)
+#define GVRENDER_DOES_MAP_ELLIPSE (1<<20)
+#define GVRENDER_DOES_MAP_BSPLINE (1<<21)
+#define GVRENDER_DOES_TOOLTIPS (1<<22)
+#define GVRENDER_DOES_TARGETS (1<<23)
+#define GVRENDER_DOES_Z (1<<24)
+#define GVRENDER_NO_BG (1<<25)
+#define LAYOUT_NOT_REQUIRED (1<<26)
+#define OUTPUT_NOT_REQUIRED (1<<27)
+
+    typedef struct {
+	int flags;
+	double default_pad;	/* graph units */
+	char **knowncolors;
+	int sz_knowncolors;
+	color_type_t color_type;
+    } gvrender_features_t;
+
+    typedef struct {
+	int flags;
+	pointf default_margin;  /* left/right, top/bottom - points */
+	pointf default_pagesize;/* default page width, height - points */
+	pointf default_dpi;
+    } gvdevice_features_t;
+
+#define LAYOUT_USES_RANKDIR (1<<0)
+
+    typedef struct gvplugin_active_device_s {
+        gvdevice_engine_t *engine;
+        int id;
+        gvdevice_features_t *features;
+        char *type;
+    } gvplugin_active_device_t;
+
+    typedef struct gvplugin_active_render_s {
+        gvrender_engine_t *engine;
+        int id;
+        gvrender_features_t *features;
+        char *type;
+    } gvplugin_active_render_t;
+
+    typedef struct gvplugin_active_loadimage_t {
+	gvloadimage_engine_t *engine;
+	int id;
+	char *type;
+    } gvplugin_active_loadimage_t;
+
+    typedef struct gv_argvlist_s {
+	char **argv;
+	int argc;
+	int alloc;
+    } gv_argvlist_t;
+
+    typedef struct gvdevice_callbacks_s {
+	void (*refresh) (GVJ_t * job);
+        void (*button_press) (GVJ_t * job, int button, pointf pointer);
+        void (*button_release) (GVJ_t * job, int button, pointf pointer);
+        void (*motion) (GVJ_t * job, pointf pointer);
+        void (*modify) (GVJ_t * job, char *name, char *value);
+        void (*del) (GVJ_t * job);  /* can't use "delete" 'cos C++ stole it */
+        void (*read) (GVJ_t * job, char *filename, char *layout);
+        void (*layout) (GVJ_t * job, char *layout);
+        void (*render) (GVJ_t * job, char *format, char *filename);
+    } gvdevice_callbacks_t;
+
+    typedef int (*gvevent_key_callback_t) (GVJ_t * job);
+
+    typedef struct gvevent_key_binding_s {
+	char *keystring;
+	gvevent_key_callback_t callback;
+    } gvevent_key_binding_t;
+
+    typedef enum {MAP_RECTANGLE, MAP_CIRCLE, MAP_POLYGON, } map_shape_t;
+
+    typedef enum {ROOTGRAPH_OBJTYPE, CLUSTER_OBJTYPE, NODE_OBJTYPE, EDGE_OBJTYPE} obj_type;
+
+    /* See comment in gvrender_core_dot.c */
+    typedef enum {
+	EMIT_GDRAW, EMIT_CDRAW, EMIT_TDRAW, EMIT_HDRAW, 
+	EMIT_GLABEL, EMIT_CLABEL, EMIT_TLABEL, EMIT_HLABEL,
+	EMIT_NDRAW, EMIT_EDRAW, EMIT_NLABEL, EMIT_ELABEL,  
+    } emit_state_t;
+
+    typedef struct obj_state_s obj_state_t;
+
+    struct obj_state_s {
+	obj_state_t *parent;
+
+	obj_type type;
+	union {
+	    graph_t *g;
+	    graph_t *sg;  
+	    node_t *n;
+	    edge_t *e;
+	} u;
+
+	emit_state_t emit_state; 
+
+	gvcolor_t pencolor, fillcolor;
+	pen_type pen;
+	fill_type fill;
+	double penwidth;
+	char **rawstyle;
+
+	double z, tail_z, head_z;   /* z depths for 2.5D renderers such as vrml */
+
+	/* fully substituted text strings */
+	char *label;
+	char *taillabel;
+	char *headlabel; 
+
+	char *url;              /* if GVRENDER_DOES_MAPS */
+	char *labelurl;
+	char *tailurl;
+	char *headurl; 
+
+	char *tooltip;          /* if GVRENDER_DOES_TOOLTIPS */
+	char *labeltooltip;
+	char *tailtooltip;
+	char *headtooltip; 
+
+	char *target;           /* if GVRENDER_DOES_TARGETS */
+	char *labeltarget;
+	char *tailtarget;
+	char *headtarget; 
+
+	int explicit_tooltip:1;
+	int explicit_tailtooltip:1;
+	int explicit_headtooltip:1;
+	int explicit_labeltooltip:1;
+	int explicit_tailtarget:1;
+	int explicit_headtarget:1;
+	int explicit_edgetarget:1;
+	int explicit_tailurl:1;
+	int explicit_headurl:1;
+
+	/* primary mapped region - node shape, edge labels */
+	map_shape_t url_map_shape; 
+	int url_map_n;                  /* number of points for url map if GVRENDER_DOES_MAPS */
+	pointf *url_map_p;
+
+	/* additonal mapped regions for edges */
+	int url_bsplinemap_poly_n;      /* number of polygons in url bspline map
+					 if GVRENDER_DOES_MAPS && GVRENDER_DOES_MAP_BSPLINES */
+	int *url_bsplinemap_n;          /* array of url_bsplinemap_poly_n ints 
+					 of number of points in each polygon */
+	pointf *url_bsplinemap_p;       /* all the polygon points */
+
+	int tailendurl_map_n;           /* tail end intersection with node */
+	pointf *tailendurl_map_p;
+
+	int headendurl_map_n;           /* head end intersection with node */
+	pointf *headendurl_map_p;
+    };
+
+/* Note on units:
+ *     points  - a physical distance (1/72 inch) unaffected by zoom or dpi.
+ *     graph units - related to physical distance by zoom.  Equals points at zoom=1
+ *     device units - related to physical distance in points by dpi/72
+ */
+
+    struct GVJ_s {
+	GVC_t *gvc;		/* parent gvc */
+	GVJ_t *next;		/* linked list of jobs */
+	GVJ_t *next_active;	/* linked list of active jobs (e.g. multiple windows) */
+
+	GVCOMMON_t *common;
+
+	obj_state_t *obj;	/* objects can be nested (at least clusters can)
+					so keep object state on a stack */
+	char *input_filename;
+	int graph_index;
+
+	char *layout_type;
+
+	char *output_filename;
+	FILE *output_file;
+	char *output_data;
+	unsigned int output_data_allocated;
+	unsigned int output_data_position;
+
+	char *output_langname;
+	int output_lang;
+
+	gvplugin_active_render_t render;
+	gvplugin_active_device_t device;
+	gvplugin_active_loadimage_t loadimage;
+	gvdevice_callbacks_t *callbacks;
+	pointf device_dpi;
+	boolean device_sets_dpi;
+
+	void *display;
+	int screen;
+
+	void *context;		/* gd or cairo surface */
+	boolean external_context;	/* context belongs to caller */
+	unsigned char *imagedata; /* location of imagedata */
+
+        int flags;		/* emit_graph flags */
+
+	int numLayers;		/* number of layers */
+	int layerNum;		/* current layer - 1 based*/
+
+	point 	pagesArraySize; /* 2D size of page array */
+	point	pagesArrayFirst;/* 2D starting corner in */
+	point	pagesArrayMajor;/* 2D major increment */
+	point	pagesArrayMinor;/* 2D minor increment */
+	point	pagesArrayElem; /* 2D coord of current page - 0,0 based */
+        int	numPages;	/* number of pages */
+
+	boxf    bb;		/* graph bb with padding - graph units */
+	pointf  pad;		/* padding around bb - graph units */
+	boxf    clip;		/* clip region in graph units */
+	boxf	pageBox;	/* current page in graph units */
+#ifdef WITH_CODEGENS
+	pointf	pageOffset;	/* offset for current page in graph units */
+#endif
+	pointf	pageSize;	/* page size in graph units */
+	pointf  focus;		/* viewport focus - graph units */
+
+	double  zoom;		/* viewport zoom factor (points per graph unit) */
+	int	rotation;	/* viewport rotation (degrees)  0=portrait, 90=landscape */
+
+	pointf  view;		/* viewport size - points */
+	boxf	canvasBox;	/* viewport area - points */
+        pointf  margin;		/* job-specific margin - points */
+
+	pointf	dpi;		/* device resolution device-units-per-inch */
+
+        unsigned int width;     /* device width - device units */
+        unsigned int height;    /* device height - device units */
+	box     pageBoundingBox;/* rotated boundingBox - device units */
+	box     boundingBox;    /* cumulative boundingBox over all pages - device units */
+
+	pointf  scale;		/* composite device to graph units (zoom and dpi) */
+	pointf  translation;    /* composite translation */
+	pointf  devscale;	/* composite device to points: dpi, y_goes_down */
+
+	boolean	fit_mode,
+		needs_refresh,
+		click,
+		has_grown,
+		has_been_rendered;
+
+	unsigned char button;   /* active button */
+	pointf pointer;		/* pointer position in device units */
+	pointf oldpointer;	/* old pointer position in device units */
+
+	void *current_obj;      /* graph object that pointer is in currently */
+
+	void *selected_obj;      /* graph object that has been selected */
+					/* (e.g. button 1 clicked on current obj) */
+	char *active_tooltip;		/* tooltip of active object - or NULL */
+	char *selected_href;		/* href of selected object - or NULL */
+	gv_argvlist_t selected_obj_type_name; /* (e.g. "edge" "node3" "e" "->" "node5" "") */
+	gv_argvlist_t selected_obj_attributes; /* attribute triplets: name, value, type */
+				/* e.g. "color", "red", GVATTR_COLOR,
+					"style", "filled", GVATTR_BOOL, */
+
+	void *window;		/* display-specific data for gvrender plugin */
+
+        /* keybindings for keyboard events */
+	gvevent_key_binding_t *keybindings;
+	int numkeys;
+	void *keycodes;
+
+/* Must be last as separately compiled plugins are not compiled with WITH_CODEGENS */
+#ifdef WITH_CODEGENS
+	codegen_t *codegen;	/* current  codegen */
+#endif
+    };
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* GVCJOB_H */
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvcommon.h b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvcommon.h
new file mode 100644
index 0000000..07e7347
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvcommon.h
@@ -0,0 +1,42 @@
+/* $Id: gvcommon.h,v 1.7 2006/12/07 22:49:36 erg Exp $ $Revision: 1.7 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+#ifndef GVCOMMON_H
+#define GVCOMMON_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    typedef struct GVCOMMON_s {
+	char *user;
+	char **info;
+	char *cmdname;
+	int verbose;
+	boolean config, auto_outfile_names;
+        void (*errorfn) (char *fmt, ...);
+	char **show_boxes; /* emit code for correct box coordinates */
+	char **lib; 
+
+	/* rendering state */
+	int viewNum;     /* current view - 1 based count of views,
+			    all pages in all layers */
+    } GVCOMMON_t;
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* GVCOMMON_H */
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvplugin.h b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvplugin.h
new file mode 100644
index 0000000..e597774
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvplugin.h
@@ -0,0 +1,67 @@
+/* $Id: gvplugin.h,v 1.26 2008/05/23 14:34:36 glenlow Exp $ $Revision: 1.26 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+/* Header used by plugins */
+
+#ifndef GVPLUGIN_H
+#define GVPLUGIN_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "gvcext.h"
+
+/* 
+ * Terminology:
+ *
+ *    package         - e.g. libgvplugin_cairo.so, or table of codegen builtins.
+ *       api	      - e.g. render
+ *          type      - e.g. "png", "ps"
+ */
+
+    typedef struct {
+	int id;         /* an id that is only unique within a package 
+			of plugins of the same api.
+			A codegen id is unique in in the set of codegens.
+			A renderer-type such as "png" in the cairo package
+			has an id that is different from the "ps" type
+			in the same package */
+	char *type;	/* a string name, such as "png" or "ps" that
+			distinguishes different types withing the same
+			api (renderer in this case) */
+	int quality;    /* an arbitrary integer used for ordering plugins of
+			the same type from different packages */
+	void *engine;   /* pointer to the jump table for the plugin */
+	void *features; /* pointer to the feature description 
+				void* because type varies by api */
+    } gvplugin_installed_t;
+
+    typedef struct {
+	api_t api;
+	gvplugin_installed_t *types;
+    } gvplugin_api_t;
+
+    typedef struct {
+	char *packagename;    /* used when this plugin is builtin and has
+					no pathname */
+	gvplugin_api_t *apis;
+    } gvplugin_library_t;
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* GVPLUGIN_H */
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvplugin_device.h b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvplugin_device.h
new file mode 100644
index 0000000..26c9ab9
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvplugin_device.h
@@ -0,0 +1,37 @@
+/* $Id: gvplugin_device.h,v 1.13 2007/10/03 16:59:11 ellson Exp $ $Revision: 1.13 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+#ifndef GVDEVICE_PLUGIN_H
+#define GVDEVICE_PLUGIN_H
+
+#include "types.h"
+#include "gvplugin.h"
+#include "gvcjob.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    struct gvdevice_engine_s {
+	void (*initialize) (GVJ_t * firstjob);
+	void (*format) (GVJ_t * firstjob);
+	void (*finalize) (GVJ_t * firstjob);
+    };
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* GVDEVICE_PLUGIN_H */
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvplugin_layout.h b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvplugin_layout.h
new file mode 100644
index 0000000..c50d298
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvplugin_layout.h
@@ -0,0 +1,36 @@
+/* $Id: gvplugin_layout.h,v 1.6 2006/06/11 19:59:03 ellson Exp $ $Revision: 1.6 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+#ifndef GVPLUGIN_LAYOUT_H
+#define GVPLUGIN_LAYOUT_H
+
+#include "types.h"
+#include "gvplugin.h"
+#include "gvcjob.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    struct gvlayout_engine_s {
+	void (*layout) (graph_t * g);
+	void (*cleanup) (graph_t * g);
+    };
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* GVPLUGIN_LAYOUT_H */
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvplugin_loadimage.h b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvplugin_loadimage.h
new file mode 100644
index 0000000..9dbcf8c
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvplugin_loadimage.h
@@ -0,0 +1,41 @@
+/* $Id: gvplugin_loadimage.h,v 1.5 2008/04/18 14:10:43 glenlow Exp $ $Revision: 1.5 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+#ifndef GVPLUGIN_IMAGELOAD_H
+#define GVPLUGIN_IMAGELOAD_H
+
+#include "types.h"
+#include "gvplugin.h"
+#include "gvcjob.h"
+
+extern void gvdevice_fputs(GVJ_t * job, char *s);
+extern void gvdevice_printf(GVJ_t * job, const char *format, ...);
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern boolean gvusershape_file_access(usershape_t *us);
+extern void gvusershape_file_release(usershape_t *us);
+
+    struct gvloadimage_engine_s {
+	void (*loadimage) (GVJ_t *job, usershape_t *us, boxf b, boolean filled);
+    };
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* GVPLUGIN_IMAGELOAD_H */
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvplugin_render.h b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvplugin_render.h
new file mode 100644
index 0000000..1e6331b
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvplugin_render.h
@@ -0,0 +1,71 @@
+/* $Id: gvplugin_render.h,v 1.29 2007/12/19 22:03:36 ellson Exp $ $Revision: 1.29 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+#ifndef GVPLUGIN_RENDER_H
+#define GVPLUGIN_RENDER_H
+
+#include "types.h"
+#include "gvplugin.h"
+#include "gvcjob.h"
+
+extern void gvdevice_fputs(GVJ_t * job, char *s);
+extern void gvdevice_printf(GVJ_t * job, const char *format, ...);
+extern void gvdevice_printnum(GVJ_t * job, double num);
+extern void gvdevice_printpointf(GVJ_t * job, pointf p);
+extern void gvdevice_printpointflist(GVJ_t * job, pointf *p, int n);
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    struct gvrender_engine_s {
+	void (*begin_job) (GVJ_t * job);
+	void (*end_job) (GVJ_t * job);
+	void (*begin_graph) (GVJ_t * job);
+	void (*end_graph) (GVJ_t * job);
+	void (*begin_layer) (GVJ_t * job, char *layername,
+			     int layerNum, int numLayers);
+	void (*end_layer) (GVJ_t * job);
+	void (*begin_page) (GVJ_t * job);
+	void (*end_page) (GVJ_t * job);
+	void (*begin_cluster) (GVJ_t * job);
+	void (*end_cluster) (GVJ_t * job);
+	void (*begin_nodes) (GVJ_t * job);
+	void (*end_nodes) (GVJ_t * job);
+	void (*begin_edges) (GVJ_t * job);
+	void (*end_edges) (GVJ_t * job);
+	void (*begin_node) (GVJ_t * job);
+	void (*end_node) (GVJ_t * job);
+	void (*begin_edge) (GVJ_t * job);
+	void (*end_edge) (GVJ_t * job);
+	void (*begin_anchor) (GVJ_t * job, char *href, char *tooltip,
+			      char *target);
+	void (*end_anchor) (GVJ_t * job);
+	void (*textpara) (GVJ_t * job, pointf p, textpara_t * str);
+	void (*resolve_color) (GVJ_t * job, gvcolor_t * color);
+	void (*ellipse) (GVJ_t * job, pointf * A, int filled);
+	void (*polygon) (GVJ_t * job, pointf * A, int n, int filled);
+	void (*beziercurve) (GVJ_t * job, pointf * A, int n,
+			     int arrow_at_start, int arrow_at_end, int);
+	void (*polyline) (GVJ_t * job, pointf * A, int n);
+	void (*comment) (GVJ_t * job, char *comment);
+	void (*library_shape) (GVJ_t * job, char *name, pointf * A, int n, int filled);
+    };
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* GVPLUGIN_RENDER_H */
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvplugin_textlayout.h b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvplugin_textlayout.h
new file mode 100644
index 0000000..a568d5a
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvplugin_textlayout.h
@@ -0,0 +1,36 @@
+/* $Id: gvplugin_textlayout.h,v 1.14 2007/08/30 19:20:21 ellson Exp $ $Revision: 1.14 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+#ifndef GVPLUGIN_TEXTLAYOUT_H
+#define GVPLUGIN_TEXTLAYOUT_H
+
+#include "types.h"
+#include "gvplugin.h"
+#include "gvcjob.h"
+#include "gvcommon.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    struct gvtextlayout_engine_s {
+	boolean (*textlayout) (textpara_t *para, char** fontpath);
+    };
+
+#ifdef __cplusplus
+}
+#endif
+#endif				/* GVPLUGIN_TEXTLAYOUT_H */
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/no_demand_loading.c b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/no_demand_loading.c
new file mode 100644
index 0000000..0a7becd
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/no_demand_loading.c
@@ -0,0 +1,17 @@
+/* $Id: no_demand_loading.c,v 1.2 2006/12/07 22:49:36 erg Exp $ $Revision: 1.2 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+const int Demand_Loading = 0;
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/pack.h b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/pack.h
new file mode 100644
index 0000000..99b97f9
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/pack.h
@@ -0,0 +1,66 @@
+/* $Id: pack.h,v 1.6 2006/12/07 22:49:37 erg Exp $ $Revision: 1.6 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+
+
+#ifndef _PACK_H
+#define _PACK_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "types.h"
+#include "graph.h"
+
+/* Type indicating granularity and method 
+ *  l_undef  - unspecified
+ *  l_node   - polyomino using nodes and edges
+ *  l_clust  - polyomino using nodes and edges and top-level clusters
+ *             (assumes ND_clust(n) unused by application)
+ *  l_graph  - polyomino using graph bounding box
+ *  l_hull   - polyomino using convex hull (unimplemented)
+ *  l_tile   - tiling using graph bounding box (unimplemented)
+ *  l_bisect - alternate bisection using graph bounding box (unimplemented)
+ */
+    typedef enum { l_undef, l_clust, l_node, l_graph } pack_mode;
+
+    typedef struct {
+#ifdef UNIMPLEMENTED
+	float aspect;		/* desired aspect ratio */
+#endif
+	unsigned int margin;	/* margin left around objects, in points */
+	int doSplines;		/* use splines in constructing graph shape */
+	pack_mode mode;		/* granularity and method */
+	boolean *fixed;		/* fixed[i] == true implies g[i] should not be moved */
+    } pack_info;
+
+    extern point *putGraphs(int, Agraph_t **, Agraph_t *, pack_info *);
+    extern int packGraphs(int, Agraph_t **, Agraph_t *, pack_info *);
+    extern int packSubgraphs(int, Agraph_t **, Agraph_t *, pack_info *);
+    extern int pack_graph(int, Agraph_t **, Agraph_t *, boolean*);
+    extern pack_mode getPackMode(Agraph_t * g, pack_mode dflt);
+    extern int getPack(Agraph_t *, int not_def, int dflt);
+
+    extern int isConnected(Agraph_t *);
+    extern Agraph_t **ccomps(Agraph_t *, int *, char *);
+    extern Agraph_t **pccomps(Agraph_t *, int *, char *, boolean *);
+    extern int nodeInduce(Agraph_t *);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/pathgeom.h b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/pathgeom.h
new file mode 100644
index 0000000..96b1fed
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/pathgeom.h
@@ -0,0 +1,54 @@
+/* $Id: pathgeom.h,v 1.2 2005/10/18 18:30:23 ellson Exp $ $Revision: 1.2 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+
+#ifndef _PATHGEOM_INCLUDE
+#define _PATHGEOM_INCLUDE
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef HAVE_POINTF_S
+    typedef struct pointf_s Ppoint_t;
+    typedef struct pointf_s Pvector_t;
+#else
+    typedef struct Pxy_t {
+	double x, y;
+    } Pxy_t;
+
+    typedef struct Pxy_t Ppoint_t;
+    typedef struct Pxy_t Pvector_t;
+#endif
+
+    typedef struct Ppoly_t {
+	Ppoint_t *ps;
+	int pn;
+    } Ppoly_t;
+
+    typedef Ppoly_t Ppolyline_t;
+
+    typedef struct Pedge_t {
+	Ppoint_t a, b;
+    } Pedge_t;
+
+/* opaque state handle for visibility graph operations */
+    typedef struct vconfig_s vconfig_t;
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/pathplan.h b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/pathplan.h
new file mode 100644
index 0000000..a360c64
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/pathplan.h
@@ -0,0 +1,55 @@
+/* $Id: pathplan.h,v 1.3 2007/01/18 20:16:45 erg Exp $ $Revision: 1.3 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+
+
+#ifndef _PATH_INCLUDE
+#define _PATH_INCLUDE
+
+#include "pathgeom.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#if defined(_BLD_pathplan) && defined(__EXPORT__)
+#   define extern __EXPORT__
+#endif
+
+/* find shortest euclidean path within a simple polygon */
+    extern int Pshortestpath(Ppoly_t * boundary, Ppoint_t endpoints[2],
+			     Ppolyline_t * output_route);
+
+/* fit a spline to an input polyline, without touching barrier segments */
+    extern int Proutespline(Pedge_t * barriers, int n_barriers,
+			    Ppolyline_t input_route,
+			    Pvector_t endpoint_slopes[2],
+			    Ppolyline_t * output_route);
+
+/* utility function to convert from a set of polygonal obstacles to barriers */
+    extern int Ppolybarriers(Ppoly_t ** polys, int npolys,
+			     Pedge_t ** barriers, int *n_barriers);
+
+/* function to convert a polyline into a spline representation */
+    extern void make_polyline(Ppolyline_t line, Ppolyline_t* sline);
+
+#undef extern
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/textpara.h b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/textpara.h
new file mode 100644
index 0000000..92d4722
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/textpara.h
@@ -0,0 +1,49 @@
+/* $Id: textpara.h,v 1.10 2008/03/06 21:40:02 ellson Exp $ $Revision: 1.10 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+#ifndef TEXTPARA_H
+#define TEXTPARA_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    typedef struct _PostscriptAlias {
+        char* name;
+        char* family;
+        char* weight;
+        char* stretch;
+        char* style;
+        int xfig_code;
+	char* svg_font_family;
+	char* svg_font_weight;
+	char* svg_font_style;
+    } PostscriptAlias;
+
+    typedef struct textpara_t {
+	char *str;      /* stored in utf-8 */
+	char *fontname; 
+	PostscriptAlias *postscript_alias; 
+	void *layout;
+	void (*free_layout) (void *layout);   /* FIXME - this is ugly */
+	double fontsize, width, height, yoffset_layout, yoffset_centerline;
+	char just;
+    } textpara_t;
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/types.h b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/types.h
new file mode 100644
index 0000000..4308ec2
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/types.h
@@ -0,0 +1,612 @@
+/* $Id: types.h,v 1.59 2008/01/08 18:18:59 ellson Exp $ $Revision: 1.59 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+#ifndef GV_TYPES_H
+#define GV_TYPES_H
+
+#include <stdio.h>
+#include <assert.h>
+#include <signal.h>
+
+typedef unsigned char boolean;
+#ifndef NOT
+#define NOT(v) (!(v))
+#endif
+#ifndef FALSE
+#define FALSE 0
+#endif
+#ifndef TRUE
+#define TRUE NOT(FALSE)
+#endif
+
+#include "geom.h"
+#include "gvcext.h"
+#include "pathgeom.h"
+#include "textpara.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    typedef int (*qsort_cmpf) (const void *, const void *);
+    typedef int (*bsearch_cmpf) (const void *, const void *);
+
+    typedef struct Agraph_t graph_t;
+    typedef struct Agnode_t node_t;
+    typedef struct Agedge_t edge_t;
+    typedef struct Agsym_t attrsym_t;
+
+    typedef struct htmllabel_t htmllabel_t;
+
+    typedef union inside_t {
+	struct {
+	    pointf* p;
+	    double* r;
+	} a;
+	struct {
+	    node_t* n;
+	    box*    bp;
+	} s;
+    } inside_t;
+
+    typedef struct port {	/* internal edge endpoint specification */
+	point p;		/* aiming point relative to node center */
+	double theta;		/* slope in radians */
+	box *bp;		/* if not null, points to bbox of 
+				 * rectangular area that is port target
+				 */
+	boolean	defined;        /* if true, edge has port info at this end */
+	boolean	constrained;    /* if true, constraints such as theta are set */
+	boolean clip;           /* if true, clip end to node/port shape */
+	unsigned char order;	/* for mincross */
+	unsigned char side;	/* if port is on perimeter of node, this
+                                 * contains the bitwise OR of the sides (TOP,
+                                 * BOTTOM, etc.) it is on. 
+                                 */
+    } port;
+
+    typedef struct {
+	boolean(*swapEnds) (edge_t * e);	/* Should head and tail be swapped? */
+	boolean(*splineMerge) (node_t * n);	/* Is n a node in the middle of an edge? */
+    } splineInfo;
+
+    typedef struct pathend_t {
+	box nb;			/* the node box */
+	point np;		/* node port */
+	int sidemask;
+	int boxn;
+	box boxes[20];
+    } pathend_t;
+
+    typedef struct path {	/* internal specification for an edge spline */
+	port start, end;
+	point *ulpp, *urpp, *llpp, *lrpp;	/* tangents of near splines */
+	int nbox;		/* number of subdivisions */
+	box *boxes;		/* rectangular regions of subdivision */
+	void *data;
+    } path;
+
+    typedef struct bezier {
+	point *list;
+	int size;
+	int sflag, eflag;
+	point sp, ep;
+    } bezier;
+
+    typedef struct splines {
+	bezier *list;
+	int size;
+	boxf bb;
+    } splines;
+
+/* fp variants */
+    typedef struct bezierf {
+	pointf *list;
+	int size;
+	int sflag, eflag;
+	pointf sp, ep;
+    } bezierf;
+
+    typedef struct splinesf {
+	bezierf *list;
+	int size;
+    } splinesf;
+
+    typedef struct textlabel_t {
+	char *text, *fontname, *fontcolor;
+	double fontsize;
+	pointf dimen;
+	point p;
+	pointf d;		/* delta from resizing */
+	union {
+	    struct {
+		textpara_t *para;
+		short nparas;
+	    } txt;
+	    htmllabel_t *html;
+	} u;
+	boolean set;		/* true if position is set */
+	boolean html;		/* true if html label */
+    } textlabel_t;
+
+    typedef struct polygon_t {	/* mutable shape information for a node */
+	int regular;		/* true for symmetric shapes */
+	int peripheries;	/* number of periphery lines */
+	int sides;		/* number of sides */
+	double orientation;	/* orientation of shape (+ve degrees) */
+	double distortion;	/* distortion factor - as in trapezium */
+	double skew;		/* skew factor - as in parallelogram */
+	int option;		/* ROUNDED, DIAGONAL corners, etc. */
+	pointf *vertices;	/* array of vertex points */
+    } polygon_t;
+
+    typedef struct stroke_t {	/* information about a single stroke */
+	/* we would have called it a path if that term wasn't already used */
+	int nvertices;		/* number of points in the stroke */
+	int flags;		/* stroke style flags */
+	pointf *vertices;	/* array of vertex points */
+    } stroke_t;
+
+/* flag definitions for stroke_t */
+#define STROKE_CLOSED (1 << 0)
+#define STROKE_FILLED (1 << 1)
+#define STROKE_PENDOWN (1 << 2)
+#define STROKE_VERTICES_ALLOCATED (1 << 3)
+
+    typedef struct shape_t {	/* mutable shape information for a node */
+	int nstrokes;		/* number of strokes in array */
+	stroke_t *strokes;	/* array of strokes */
+	/* The last stroke must always be closed, but can be pen_up.
+	 * It is used as the clipping path */
+    } shape_t;
+
+    typedef struct shape_functions {	/* read-only shape functions */
+	void (*initfn) (node_t *);	/* initializes shape from node u.shape_info structure */
+	void (*freefn) (node_t *);	/* frees  shape from node u.shape_info structure */
+	 port(*portfn) (node_t *, char *, char *);	/* finds aiming point and slope of port */
+	 boolean(*insidefn) (inside_t * inside_context, pointf);	/* clips incident gvc->e spline on shape of gvc->n */
+	int (*pboxfn)(node_t* n, port* p, int side, box rv[], int *kptr); /* finds box path to reach port */
+	void (*codefn) (GVJ_t * job, node_t * n);	/* emits graphics code for node */
+    } shape_functions;
+
+    typedef enum { SH_UNSET, SH_POLY, SH_RECORD, SH_POINT, SH_EPSF} shape_kind;
+
+    typedef struct shape_desc {	/* read-only shape descriptor */
+	char *name;		/* as read from graph file */
+	shape_functions *fns;
+	polygon_t *polygon;	/* base polygon info */
+	boolean usershape;
+    } shape_desc;
+
+#include "usershape.h"		/* usershapes needed by gvc even w/o CODEGENS */
+#ifdef WITH_CODEGENS
+
+    struct codegen_s {
+	void (*reset) (void);
+	void (*begin_job) (FILE * ofp, graph_t * g, char **lib, char *user,
+			   char *info[], point pages);
+	void (*end_job) (void);
+	void (*begin_graph) (GVC_t * gvc, graph_t * g, box bb, point pb);
+	void (*end_graph) (void);
+	void (*begin_page) (graph_t * g, point page, double scale, int rot,
+			    point offset);
+	void (*end_page) (void);
+	void (*begin_layer) (char *layerName, int n, int nLayers);
+	void (*end_layer) (void);
+	void (*begin_cluster) (graph_t * g);
+	void (*end_cluster) (void);
+	void (*begin_nodes) (void);
+	void (*end_nodes) (void);
+	void (*begin_edges) (void);
+	void (*end_edges) (void);
+	void (*begin_node) (node_t * n);
+	void (*end_node) (void);
+	void (*begin_edge) (edge_t * e);
+	void (*end_edge) (void);
+	void (*begin_context) (void);
+	void (*end_context) (void);
+	void (*begin_anchor) (char *href, char *tooltip, char *target);
+	void (*end_anchor) (void);
+	void (*set_font) (char *fontname, double fontsize);
+	void (*textpara) (point p, textpara_t * para);
+	void (*set_pencolor) (char *name);
+	void (*set_fillcolor) (char *name);
+	void (*set_style) (char **s);
+	void (*ellipse) (point p, int rx, int ry, int filled);
+	void (*polygon) (point * A, int n, int filled);
+	void (*beziercurve) (point * A, int n, int arrow_at_start,
+			     int arrow_at_end, int filled);
+	void (*polyline) (point * A, int n);
+	boolean bezier_has_arrows;
+	void (*comment) (char *str);
+	void (*usershape) (usershape_t *us, boxf b, point * A, int sides, boolean filled);
+	void (*set_penwidth) (double penwidth);
+    };
+
+    struct codegen_info_s {
+	codegen_t *cg;		/* discovered codegen */
+	char *name;		/* output format, null for sentinel */
+	int id;			/* id of output format */
+	void *info;		/* additional info provided by discovery routine */
+	/* Quartz uses this to store the Quicktime Component */
+    };
+
+#endif
+
+    typedef struct nodequeue {
+	node_t **store, **limit, **head, **tail;
+    } nodequeue;
+
+    typedef struct adjmatrix_t {
+	int nrows, ncols;
+	char *data;
+    } adjmatrix_t;
+
+    typedef struct rank_t {
+	int n;			/* number of nodes in this rank  */
+	node_t **v;		/* ordered list of nodes in rank    */
+	int an;			/* globally allocated number of nodes   */
+	node_t **av;		/* allocated list of nodes in rank  */
+	int ht1, ht2;		/* height below/above centerline    */
+	int pht1, pht2;		/* as above, but only primitive nodes   */
+	boolean candidate;	/* for transpose () */
+	boolean valid;
+	int cache_nc;		/* caches number of crossings */
+	adjmatrix_t *flat;
+    } rank_t;
+
+    typedef enum { R_NONE =
+	    0, R_VALUE, R_FILL, R_COMPRESS, R_AUTO, R_EXPAND } ratio_t;
+
+    typedef struct layout_t {
+	double quantum;
+	double scale;
+	double ratio;		/* set only if ratio_kind == R_VALUE */
+	double dpi;
+	point margin;
+	point page;
+	point  size;
+	boolean filled;
+	boolean landscape;
+	boolean centered;
+	ratio_t ratio_kind;
+    } layout_t;
+
+/* for "record" shapes */
+    typedef struct field_t {
+	point size;		/* its dimension */
+	box b;			/* its placement in node's coordinates */
+	int n_flds;
+	textlabel_t *lp;	/* n_flds == 0 */
+	struct field_t **fld;	/* n_flds > 0 */
+	char *id;		/* user's identifier */
+	unsigned char LR;	/* if box list is horizontal (left to right) */
+	unsigned char sides;    /* sides of node exposed to field */
+    } field_t;
+
+    typedef struct nlist_t {
+	node_t **list;
+	int size;
+    } nlist_t;
+
+    typedef struct elist {
+	edge_t **list;
+	int size;
+    } elist;
+
+#define GUI_STATE_ACTIVE    (1<<0)
+#define GUI_STATE_SELECTED  (1<<1)
+#define GUI_STATE_VISITED   (1<<2)
+#define GUI_STATE_DELETED   (1<<3)
+
+#define elist_fastapp(item,L) do {L.list[L.size++] = item; L.list[L.size] = NULL;} while(0)
+#define elist_append(item,L)  do {L.list = ALLOC(L.size + 2,L.list,edge_t*); L.list[L.size++] = item; L.list[L.size] = NULL;} while(0)
+#define alloc_elist(n,L)      do {L.size = 0; L.list = N_NEW(n + 1,edge_t*); } while (0)
+#define free_list(L)          do {if (L.list) free(L.list);} while (0)
+
+typedef enum {NATIVEFONTS,PSFONTS,SVGFONTS} fontname_kind;
+
+    typedef struct Agraphinfo_t {
+	/* to generate code */
+	layout_t *drawing;
+	textlabel_t *label;	/* if the cluster has a title */
+	box bb;			/* bounding box */
+	point border[4];	/* sizes of margins for graph labels */
+	unsigned char gui_state; /* Graph state for GUI ops */
+	unsigned char has_labels;
+	boolean has_images;
+	unsigned char charset; /* input character set */
+	int rankdir;
+	int ht1, ht2;	/* below and above extremal ranks */
+	unsigned short flags;
+	void *alg;
+	GVC_t *gvc;	/* context for "globals" over multiple graphs */
+	void (*cleanup) (graph_t * g);   /* function to deallocate layout-specific data */
+
+#ifndef DOT_ONLY
+	/* to place nodes */
+	node_t **neato_nlist;
+	int move;
+	double **dist, **spring, **sum_t, ***t;
+	int ndim;
+#endif
+#ifndef NEATO_ONLY
+	/* to have subgraphs */
+	int n_cluster;
+	graph_t **clust;	/* clusters are in clust[1..n_cluster] !!! */
+	node_t *nlist;
+	rank_t *rank;
+	/* fast graph node list */
+	nlist_t comp;
+	/* connected components */
+	node_t *minset, *maxset;	/* set leaders */
+	long n_nodes;
+	/* includes virtual */
+	short minrank, maxrank;
+
+	/* various flags */
+	boolean has_flat_edges;
+	unsigned char	showboxes;
+	boolean cluster_was_collapsed;
+	fontname_kind fontnames;		/* to override mangling in SVG */
+
+	int nodesep, ranksep;
+	node_t *ln, *rn;	/* left, right nodes of bounding box */
+
+
+	/* for clusters */
+	node_t *leader, **rankleader;
+	boolean expanded;
+	char installed;
+	char set_type;
+	char label_pos;
+	boolean exact_ranksep;
+#endif
+
+    } Agraphinfo_t;
+
+#define GD_alg(g) (g)->u.alg
+#define GD_bb(g) (g)->u.bb
+#define GD_border(g) (g)->u.border
+#define GD_cl_cnt(g) (g)->u.cl_cnt
+#define GD_cleanup(g) (g)->u.cleanup
+#define GD_clust(g) (g)->u.clust
+#define GD_cluster_was_collapsed(g) (g)->u.cluster_was_collapsed
+#define GD_comp(g) (g)->u.comp
+#define GD_dist(g) (g)->u.dist
+#define GD_drawing(g) (g)->u.drawing
+#define GD_exact_ranksep(g) (g)->u.exact_ranksep
+#define GD_expanded(g) (g)->u.expanded
+#define GD_flags(g) (g)->u.flags
+#define GD_gui_state(g) (g)->u.gui_state
+#define GD_gvc(g) (g)->u.gvc
+#define GD_charset(g) (g)->u.charset
+#define GD_has_labels(g) (g)->u.has_labels
+#define GD_has_images(g) (g)->u.has_images
+#define GD_has_flat_edges(g) (g)->u.has_flat_edges
+#define GD_ht1(g) (g)->u.ht1
+#define GD_ht2(g) (g)->u.ht2
+#define GD_inleaf(g) (g)->u.inleaf
+#define GD_installed(g) (g)->u.installed
+#define GD_label(g) (g)->u.label
+#define GD_leader(g) (g)->u.leader
+#define GD_rankdir(g) ((g)->u.rankdir & 0x3)
+#define GD_flip(g) (GD_rankdir(g) & 1)
+#define GD_realrankdir(g) ((g)->u.rankdir >> 2)
+#define GD_realflip(g) (GD_realrankdir(g) & 1)
+#define GD_ln(g) (g)->u.ln
+#define GD_maxrank(g) (g)->u.maxrank
+#define GD_maxset(g) (g)->u.maxset
+#define GD_minrank(g) (g)->u.minrank
+#define GD_minset(g) (g)->u.minset
+#define GD_move(g) (g)->u.move
+#define GD_n_cluster(g) (g)->u.n_cluster
+#define GD_n_nodes(g) (g)->u.n_nodes
+#define GD_ndim(g) (g)->u.ndim
+#define GD_neato_nlist(g) (g)->u.neato_nlist
+#define GD_nlist(g) (g)->u.nlist
+#define GD_nodesep(g) (g)->u.nodesep
+#define GD_outleaf(g) (g)->u.outleaf
+#define GD_rank(g) (g)->u.rank
+#define GD_rankleader(g) (g)->u.rankleader
+#define GD_ranksep(g) (g)->u.ranksep
+#define GD_rn(g) (g)->u.rn
+#define GD_set_type(g) (g)->u.set_type
+#define GD_label_pos(g) (g)->u.label_pos
+#define GD_showboxes(g) (g)->u.showboxes
+#define GD_fontnames(g) (g)->u.fontnames
+#define GD_spring(g) (g)->u.spring
+#define GD_sum_t(g) (g)->u.sum_t
+#define GD_t(g) (g)->u.t
+
+    typedef struct Agnodeinfo_t {
+	shape_desc *shape;
+	void *shape_info;
+	point coord;
+	double width, height;
+	boxf bb;
+	int ht, lw, rw;
+	textlabel_t *label;
+	void *alg;
+	char state;
+	unsigned char gui_state; /* Node state for GUI ops */
+	boolean clustnode;
+
+#ifndef DOT_ONLY
+	unsigned char pinned;
+	short xsize, ysize;
+	int id, heapindex, hops;
+	double *pos, dist;
+#endif
+#ifndef NEATO_ONLY
+	unsigned char showboxes;
+	boolean  has_port;
+
+	/* fast graph */
+	char node_type, mark, onstack;
+	char ranktype, weight_class;
+	node_t *next, *prev;
+	elist in, out, flat_out, flat_in, other;
+	graph_t *clust;
+
+	/* for union-find and collapsing nodes */
+	int UF_size;
+	node_t *UF_parent;
+	node_t *inleaf, *outleaf;
+
+	/* for placing nodes */
+	int rank, order;	/* initially, order = 1 for ordered edges */
+	int mval;
+	elist save_in, save_out;
+
+	/* for network-simplex */
+	elist tree_in, tree_out;
+	edge_t *par;
+	int low, lim;
+	int priority;
+
+	double pad[1];
+#endif
+
+    } Agnodeinfo_t;
+
+#define ND_UF_parent(n) (n)->u.UF_parent
+#define ND_UF_size(n) (n)->u.UF_size
+#define ND_alg(n) (n)->u.alg
+#define ND_bb(n) (n)->u.bb
+#define ND_clust(n) (n)->u.clust
+#define ND_coord_i(n) (n)->u.coord
+#define ND_dist(n) (n)->u.dist
+#define ND_flat_in(n) (n)->u.flat_in
+#define ND_flat_out(n) (n)->u.flat_out
+#define ND_gui_state(n) (n)->u.gui_state
+#define ND_has_port(n) (n)->u.has_port
+#define ND_heapindex(n) (n)->u.heapindex
+#define ND_height(n) (n)->u.height
+#define ND_hops(n) (n)->u.hops
+#define ND_ht_i(n) (n)->u.ht
+#define ND_id(n) (n)->u.id
+#define ND_in(n) (n)->u.in
+#define ND_inleaf(n) (n)->u.inleaf
+#define ND_label(n) (n)->u.label
+#define ND_lim(n) (n)->u.lim
+#define ND_low(n) (n)->u.low
+#define ND_lw_i(n) (n)->u.lw
+#define ND_mark(n) (n)->u.mark
+#define ND_mval(n) (n)->u.mval
+#define ND_n_cluster(n) (n)->u.n_cluster
+#define ND_next(n) (n)->u.next
+#define ND_node_type(n) (n)->u.node_type
+#define ND_onstack(n) (n)->u.onstack
+#define ND_order(n) (n)->u.order
+#define ND_other(n) (n)->u.other
+#define ND_out(n) (n)->u.out
+#define ND_outleaf(n) (n)->u.outleaf
+#define ND_par(n) (n)->u.par
+#define ND_pinned(n) (n)->u.pinned
+#define ND_pos(n) (n)->u.pos
+#define ND_prev(n) (n)->u.prev
+#define ND_priority(n) (n)->u.priority
+#define ND_rank(n) (n)->u.rank
+#define ND_ranktype(n) (n)->u.ranktype
+#define ND_rw_i(n) (n)->u.rw
+#define ND_save_in(n) (n)->u.save_in
+#define ND_save_out(n) (n)->u.save_out
+#define ND_shape(n) (n)->u.shape
+#define ND_shape_info(n) (n)->u.shape_info
+#define ND_showboxes(n) (n)->u.showboxes
+#define ND_state(n) (n)->u.state
+#define ND_clustnode(n) (n)->u.clustnode
+#define ND_tree_in(n) (n)->u.tree_in
+#define ND_tree_out(n) (n)->u.tree_out
+#define ND_weight_class(n) (n)->u.weight_class
+#define ND_width(n) (n)->u.width
+#define ND_xsize(n) (n)->u.xsize
+#define ND_ysize(n) (n)->u.ysize
+
+    typedef struct Agedgeinfo_t {
+	splines *spl;
+	port tail_port, head_port;	/* might be used someday */
+	textlabel_t *label, *head_label, *tail_label;
+	char edge_type;
+	char adjacent;          /* true for flat edge with adjacent nodes */
+	char label_ontop;
+	unsigned char gui_state; /* Edge state for GUI ops */
+	edge_t *to_orig;	/* for dot's shapes.c    */
+	void *alg;
+
+#ifndef DOT_ONLY
+	double factor;
+	double dist;
+	Ppolyline_t path;
+#endif
+#ifndef NEATO_ONLY
+	unsigned char showboxes;
+	boolean conc_opp_flag;
+	short xpenalty;
+	int weight;
+	int cutvalue, tree_index;
+	short count;
+	unsigned short minlen;
+	edge_t *to_virt;
+#endif
+
+    } Agedgeinfo_t;
+
+#define ED_alg(e) (e)->u.alg
+#define ED_conc_opp_flag(e) (e)->u.conc_opp_flag
+#define ED_count(e) (e)->u.count
+#define ED_cutvalue(e) (e)->u.cutvalue
+#define ED_dist(e) (e)->u.dist
+#define ED_edge_type(e) (e)->u.edge_type
+#define ED_adjacent(e) (e)->u.adjacent
+#define ED_factor(e) (e)->u.factor
+#define ED_gui_state(e) (e)->u.gui_state
+#define ED_head_label(e) (e)->u.head_label
+#define ED_head_port(e) (e)->u.head_port
+#define ED_label(e) (e)->u.label
+#define ED_label_ontop(e) (e)->u.label_ontop
+#define ED_minlen(e) (e)->u.minlen
+#define ED_path(e) (e)->u.path
+#define ED_showboxes(e) (e)->u.showboxes
+#define ED_spl(e) (e)->u.spl
+#define ED_tail_label(e) (e)->u.tail_label
+#define ED_tail_port(e) (e)->u.tail_port
+#define ED_to_orig(e) (e)->u.to_orig
+#define ED_to_virt(e) (e)->u.to_virt
+#define ED_tree_index(e) (e)->u.tree_index
+#define ED_weight(e) (e)->u.weight
+#define ED_xpenalty(e) (e)->u.xpenalty
+
+    typedef struct {
+        int useGrid;            /* use grid for speed up */
+        int useNew;             /* encode x-K into attractive force */
+        int numIters;           /* actual iterations in layout */
+        int unscaled;           /* % of iterations used in pass 1 */
+        double C;               /* Repulsion factor in xLayout */
+        double Tfact;           /* scale temp from default expression */
+        double K;               /* spring constant; ideal distance */
+        double T0;              /* initial temperature */
+    } fdpParms_t;
+
+    typedef struct {
+	int flags;
+    } gvlayout_features_t;
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/usershape.h b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/usershape.h
new file mode 100644
index 0000000..f7f07e4
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/usershape.h
@@ -0,0 +1,59 @@
+/* $Id: usershape.h,v 1.12 2008/03/15 23:19:30 ellson Exp $ $Revision: 1.12 $ */
+/* vim:set shiftwidth=4 ts=8: */
+
+/**********************************************************
+*      This software is part of the graphviz package      *
+*                http://www.graphviz.org/                 *
+*                                                         *
+*            Copyright (c) 1994-2004 AT&T Corp.           *
+*                and is licensed under the                *
+*            Common Public License, Version 1.0           *
+*                      by AT&T Corp.                      *
+*                                                         *
+*        Information and Software Systems Research        *
+*              AT&T Research, Florham Park NJ             *
+**********************************************************/
+
+#ifndef USERSHAPE_H
+#define USERSHAPE_H
+
+#include "cdt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    typedef enum { FT_NULL,
+		FT_BMP, FT_GIF, FT_PNG, FT_JPEG,
+		FT_PDF, FT_PS, FT_EPS, FT_SVG, FT_XML
+    } imagetype_t;
+
+    typedef enum {
+	IMAGESCALE_FALSE,  /* no image scaling */
+	IMAGESCALE_TRUE,   /* scale image to fit but keep aspect ratio */
+	IMAGESCALE_WIDTH,  /* scale image width to fit, keep height fixed */
+	IMAGESCALE_HEIGHT, /* scale image height to fit, keep width fixed */
+	IMAGESCALE_BOTH    /* scale image to fit without regard for aspect ratio */
+    } imagescale_t;
+
+    typedef struct usershape_s usershape_t;
+
+    struct usershape_s {
+	Dtlink_t link;
+	char *name;
+	int macro_id;
+	boolean must_inline;
+	boolean nocache;
+	FILE *f;
+	imagetype_t type;
+	char *stringtype;
+	int x, y, w, h, dpi;
+	void *data;                   /* data loaded by a renderer */
+	size_t datasize;              /* size of data (if mmap'ed) */
+	void (*datafree)(usershape_t *us); /* renderer's function for freeing data */
+    };
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/ltdl.h b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/ltdl.h
new file mode 100644
index 0000000..66b4dd9
--- /dev/null
+++ b/Master/Agile Software Development/TestApp/dist/lib/graphviz/include/ltdl.h
@@ -0,0 +1,366 @@
+/* ltdl.h -- generic dlopen functions
+   Copyright (C) 1998-2000 Free Software Foundation, Inc.
+   Originally by Thomas Tanner <tanner@ffii.org>
+   This file is part of GNU Libtool.
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2 of the License, or (at your option) any later version.
+
+As a special exception to the GNU Lesser General Public License,
+if you distribute this file as part of a program or library that
+is built using GNU libtool, you may include it under the same
+distribution terms that you use for the rest of that program.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free
+Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+02111-1307  USA
+*/
+
+/* Only include this header file once. */
+#ifndef LTDL_H
+#define LTDL_H 1
+
+#include <sys/types.h>		/* for size_t declaration */
+
+
+/* --- MACROS FOR PORTABILITY --- */
+
+
+/* Saves on those hard to debug '\0' typos....  */
+#define LT_EOS_CHAR	'\0'
+
+/* LTDL_BEGIN_C_DECLS should be used at the beginning of your declarations,
+   so that C++ compilers don't mangle their names.  Use LTDL_END_C_DECLS at
+   the end of C declarations. */
+#ifdef __cplusplus
+# define LT_BEGIN_C_DECLS	extern "C" {
+# define LT_END_C_DECLS		}
+#else
+# define LT_BEGIN_C_DECLS	/* empty */
+# define LT_END_C_DECLS		/* empty */
+#endif
+
+LT_BEGIN_C_DECLS
+
+
+/* LT_PARAMS is a macro used to wrap function prototypes, so that compilers
+   that don't understand ANSI C prototypes still work, and ANSI C
+   compilers can issue warnings about type mismatches.  */
+#if defined (__STDC__) || defined (_AIX) || (defined (__mips) && defined (_SYSTYPE_SVR4)) || defined(WIN32) || defined(__cplusplus)
+# define LT_PARAMS(protos)	protos
+# define lt_ptr		void*
+#else
+# define LT_PARAMS(protos)	()
+# define lt_ptr		char*
+#endif
+
+/* LT_STMT_START/END are used to create macros which expand to a
+   a single compound statement in a portable way.  */
+#if defined (__GNUC__) && !defined (__STRICT_ANSI__) && !defined (__cplusplus)
+#  define LT_STMT_START        (void)(
+#  define LT_STMT_END          )
+#else
+#  if (defined (sun) || defined (__sun__))
+#    define LT_STMT_START      if (1)
+#    define LT_STMT_END        else (void)0
+#  else
+#    define LT_STMT_START      do
+#    define LT_STMT_END        while (0)
+#  endif
+#endif
+
+/* LT_CONC creates a new concatenated symbol for the compiler
+   in a portable way.  */
+#if defined(__STDC__) || defined(__cplusplus) || defined(_MSC_VER)
+#  define LT_CONC(s,t)	s##t
+#else
+#  define LT_CONC(s,t)	s/**/t
+#endif
+
+/* LT_STRLEN can be used safely on NULL pointers.  */
+#define LT_STRLEN(s)	(((s) && (s)[0]) ? strlen (s) : 0)
+
+
+
+/* --- WINDOWS SUPPORT --- */
+
+
+/* Canonicalise Windows and Cygwin recognition macros.  */
+#ifdef __CYGWIN32__
+#  ifndef __CYGWIN__
+#    define __CYGWIN__ __CYGWIN32__
+#  endif
+#endif
+#if defined(_WIN32) || defined(WIN32)
+#  ifndef __WINDOWS__
+#    ifdef _WIN32
+#      define __WINDOWS__ _WIN32
+#    else
+#      ifdef WIN32
+#        define __WINDOWS__ WIN32
+#      endif
+#    endif
+#  endif
+#endif
+
+
+#ifdef __WINDOWS__
+#  ifndef __CYGWIN__
+/* LT_DIRSEP_CHAR is accepted *in addition* to '/' as a directory
+   separator when it is set. */
+#    define LT_DIRSEP_CHAR	'\\'
+#    define LT_PATHSEP_CHAR	';'
+#  endif
+#endif
+#ifndef LT_PATHSEP_CHAR
+#  define LT_PATHSEP_CHAR	':'
+#endif
+
+/* DLL building support on win32 hosts;  mostly to workaround their
+   ridiculous implementation of data symbol exporting. */
+#ifndef LT_SCOPE
+#  ifdef __WINDOWS__
+#    ifdef LIBLTDL_DLL_EXPORT		/* defined if exporting this dll */
+#      define LT_SCOPE	__declspec(dllexport)
+#    endif
+#    ifdef LIBLTDL_DLL_IMPORT	/* define if linking with this dll */
+#      define LT_SCOPE	extern __declspec(dllimport)
+#    endif
+#  endif
+#  ifndef LT_SCOPE		/* static linking or !__WINDOWS__ */
+#    define LT_SCOPE	extern
+#  endif
+#endif
+
+
+#if defined(_MSC_VER) /* Visual Studio */
+#  define R_OK 4
+#endif
+
+
+
+/* --- DYNAMIC MODULE LOADING API --- */
+
+
+typedef	struct lt_dlhandle_struct *lt_dlhandle;	/* A loaded module.  */
+
+/* Initialisation and finalisation functions for libltdl. */
+LT_SCOPE	int	    lt_dlinit		LT_PARAMS((void));
+LT_SCOPE	int	    lt_dlexit		LT_PARAMS((void));
+
+/* Module search path manipulation.  */
+LT_SCOPE	int	    lt_dladdsearchdir	 LT_PARAMS((const char *search_dir));
+LT_SCOPE	int	    lt_dlinsertsearchdir LT_PARAMS((const char *before,
+						    const char *search_dir));
+LT_SCOPE	int 	    lt_dlsetsearchpath	 LT_PARAMS((const char *search_path));
+LT_SCOPE	const char *lt_dlgetsearchpath	 LT_PARAMS((void));
+LT_SCOPE	int	    lt_dlforeachfile	 LT_PARAMS((
+			const char *search_path,
+			int (*func) (const char *filename, lt_ptr data),
+			lt_ptr data));
+
+/* Portable libltdl versions of the system dlopen() API. */
+LT_SCOPE	lt_dlhandle lt_dlopen		LT_PARAMS((const char *filename));
+LT_SCOPE	lt_dlhandle lt_dlopenext	LT_PARAMS((const char *filename));
+LT_SCOPE	lt_ptr	    lt_dlsym		LT_PARAMS((lt_dlhandle handle,
+						     const char *name));
+LT_SCOPE	const char *lt_dlerror		LT_PARAMS((void));
+LT_SCOPE	int	    lt_dlclose		LT_PARAMS((lt_dlhandle handle));
+
+/* Module residency management. */
+LT_SCOPE	int	    lt_dlmakeresident	LT_PARAMS((lt_dlhandle handle));
+LT_SCOPE	int	    lt_dlisresident	LT_PARAMS((lt_dlhandle handle));
+
+
+
+
+/* --- MUTEX LOCKING --- */
+
+
+typedef void	lt_dlmutex_lock		LT_PARAMS((void));
+typedef void	lt_dlmutex_unlock	LT_PARAMS((void));
+typedef void	lt_dlmutex_seterror	LT_PARAMS((const char *errmsg));
+typedef const char *lt_dlmutex_geterror	LT_PARAMS((void));
+
+LT_SCOPE	int	lt_dlmutex_register	LT_PARAMS((lt_dlmutex_lock *lock,
+					    lt_dlmutex_unlock *unlock,
+					    lt_dlmutex_seterror *seterror,
+					    lt_dlmutex_geterror *geterror));
+
+
+
+
+/* --- MEMORY HANDLING --- */
+
+
+/* By default, the realloc function pointer is set to our internal
+   realloc implementation which iself uses lt_dlmalloc and lt_dlfree.
+   libltdl relies on a featureful realloc, but if you are sure yours
+   has the right semantics then you can assign it directly.  Generally,
+   it is safe to assign just a malloc() and a free() function.  */
+LT_SCOPE  lt_ptr   (*lt_dlmalloc)	LT_PARAMS((size_t size));
+LT_SCOPE  lt_ptr   (*lt_dlrealloc)	LT_PARAMS((lt_ptr ptr, size_t size));
+LT_SCOPE  void	   (*lt_dlfree)		LT_PARAMS((lt_ptr ptr));
+
+
+
+
+/* --- PRELOADED MODULE SUPPORT --- */
+
+
+/* A preopened symbol. Arrays of this type comprise the exported
+   symbols for a dlpreopened module. */
+typedef struct {
+  const char *name;
+  lt_ptr      address;
+} lt_dlsymlist;
+
+LT_SCOPE	int	lt_dlpreload	LT_PARAMS((const lt_dlsymlist *preloaded));
+LT_SCOPE	int	lt_dlpreload_default
+				LT_PARAMS((const lt_dlsymlist *preloaded));
+
+#define LTDL_SET_PRELOADED_SYMBOLS() 		LT_STMT_START{	\
+	extern const lt_dlsymlist lt_preloaded_symbols[];		\
+	lt_dlpreload_default(lt_preloaded_symbols);			\
+						}LT_STMT_END
+
+
+
+
+/* --- MODULE INFORMATION --- */
+
+
+/* Read only information pertaining to a loaded module. */
+typedef	struct {
+  char	*filename;		/* file name */
+  char	*name;			/* module name */
+  int	ref_count;		/* number of times lt_dlopened minus
+				   number of times lt_dlclosed. */
+} lt_dlinfo;
+
+LT_SCOPE	const lt_dlinfo	*lt_dlgetinfo	    LT_PARAMS((lt_dlhandle handle));
+LT_SCOPE	lt_dlhandle	lt_dlhandle_next    LT_PARAMS((lt_dlhandle place));
+LT_SCOPE	int		lt_dlforeach	    LT_PARAMS((
+				int (*func) (lt_dlhandle handle, lt_ptr data),
+				lt_ptr data));
+
+/* Associating user data with loaded modules. */
+typedef unsigned lt_dlcaller_id;
+
+LT_SCOPE	lt_dlcaller_id	lt_dlcaller_register  LT_PARAMS((void));
+LT_SCOPE	lt_ptr		lt_dlcaller_set_data  LT_PARAMS((lt_dlcaller_id key,
+						lt_dlhandle handle,
+						lt_ptr data));
+LT_SCOPE	lt_ptr		lt_dlcaller_get_data  LT_PARAMS((lt_dlcaller_id key,
+						lt_dlhandle handle));
+
+
+
+/* --- USER MODULE LOADER API --- */
+
+
+typedef	struct lt_dlloader	lt_dlloader;
+typedef lt_ptr			lt_user_data;
+typedef lt_ptr			lt_module;
+
+/* Function pointer types for creating user defined module loaders. */
+typedef lt_module   lt_module_open	LT_PARAMS((lt_user_data loader_data,
+					    const char *filename));
+typedef int	    lt_module_close	LT_PARAMS((lt_user_data loader_data,
+					    lt_module handle));
+typedef lt_ptr	    lt_find_sym		LT_PARAMS((lt_user_data loader_data,
+					    lt_module handle,
+					    const char *symbol));
+typedef int	    lt_dlloader_exit	LT_PARAMS((lt_user_data loader_data));
+
+struct lt_user_dlloader {
+  const char	       *sym_prefix;
+  lt_module_open       *module_open;
+  lt_module_close      *module_close;
+  lt_find_sym	       *find_sym;
+  lt_dlloader_exit     *dlloader_exit;
+  lt_user_data		dlloader_data;
+};
+
+LT_SCOPE	lt_dlloader    *lt_dlloader_next    LT_PARAMS((lt_dlloader *place));
+LT_SCOPE	lt_dlloader    *lt_dlloader_find    LT_PARAMS((
+						const char *loader_name));
+LT_SCOPE	const char     *lt_dlloader_name    LT_PARAMS((lt_dlloader *place));
+LT_SCOPE	lt_user_data   *lt_dlloader_data    LT_PARAMS((lt_dlloader *place));
+LT_SCOPE	int		lt_dlloader_add     LT_PARAMS((lt_dlloader *place,
+				const struct lt_user_dlloader *dlloader,
+				const char *loader_name));
+LT_SCOPE	int		lt_dlloader_remove  LT_PARAMS((
+						const char *loader_name));
+
+
+
+/* --- ERROR MESSAGE HANDLING --- */
+
+
+/* Defining error strings alongside their symbolic names in a macro in
+   this way allows us to expand the macro in different contexts with
+   confidence that the enumeration of symbolic names will map correctly
+   onto the table of error strings.  */
+#define lt_dlerror_table						\
+    LT_ERROR(UNKNOWN,		    "unknown error")			\
+    LT_ERROR(DLOPEN_NOT_SUPPORTED,  "dlopen support not available")	\
+    LT_ERROR(INVALID_LOADER,	    "invalid loader")			\
+    LT_ERROR(INIT_LOADER,	    "loader initialization failed")	\
+    LT_ERROR(REMOVE_LOADER,	    "loader removal failed")		\
+    LT_ERROR(FILE_NOT_FOUND,	    "file not found")			\
+    LT_ERROR(DEPLIB_NOT_FOUND,      "dependency library not found")	\
+    LT_ERROR(NO_SYMBOLS,	    "no symbols defined")		\
+    LT_ERROR(CANNOT_OPEN,	    "can't open the module")		\
+    LT_ERROR(CANNOT_CLOSE,	    "can't close the module")		\
+    LT_ERROR(SYMBOL_NOT_FOUND,      "symbol not found")			\
+    LT_ERROR(NO_MEMORY,		    "not enough memory")		\
+    LT_ERROR(INVALID_HANDLE,	    "invalid module handle")		\
+    LT_ERROR(BUFFER_OVERFLOW,	    "internal buffer overflow")		\
+    LT_ERROR(INVALID_ERRORCODE,     "invalid errorcode")		\
+    LT_ERROR(SHUTDOWN,		    "library already shutdown")		\
+    LT_ERROR(CLOSE_RESIDENT_MODULE, "can't close resident module")	\
+    LT_ERROR(INVALID_MUTEX_ARGS,    "invalid mutex handler registration") \
+    LT_ERROR(INVALID_POSITION,	    "invalid search path insert position")
+
+/* Enumerate the symbolic error names. */
+enum {
+#define LT_ERROR(name, diagnostic)	LT_CONC(LT_ERROR_, name),
+	lt_dlerror_table
+#undef LT_ERROR
+
+	LT_ERROR_MAX
+};
+
+/* These functions are only useful from inside custom module loaders. */
+LT_SCOPE	int	lt_dladderror	LT_PARAMS((const char *diagnostic));
+LT_SCOPE	int	lt_dlseterror	LT_PARAMS((int errorcode));
+
+
+
+
+/* --- SOURCE COMPATIBILITY WITH OLD LIBLTDL --- */
+
+
+#ifdef LT_NON_POSIX_NAMESPACE
+#  define lt_ptr_t		lt_ptr
+#  define lt_module_t		lt_module
+#  define lt_module_open_t	lt_module_open
+#  define lt_module_close_t	lt_module_close
+#  define lt_find_sym_t		lt_find_sym
+#  define lt_dlloader_exit_t	lt_dlloader_exit
+#  define lt_dlloader_t		lt_dlloader
+#  define lt_dlloader_data_t	lt_user_data
+#endif
+
+LT_END_C_DECLS
+
+#endif /* !LTDL_H */