From 33613a85afc4b1481367fbe92a17ee59c240250b Mon Sep 17 00:00:00 2001 From: Sven Eisenhauer Date: Fri, 10 Nov 2023 15:11:48 +0100 Subject: add new repo --- .../dist/lib/graphviz/include/graphviz/arith.h | 102 +++ .../dist/lib/graphviz/include/graphviz/cdt.h | 249 ++++++ .../dist/lib/graphviz/include/graphviz/cgraph.h | 454 ++++++++++ .../dist/lib/graphviz/include/graphviz/color.h | 57 ++ .../lib/graphviz/include/graphviz/demand_loading.c | 17 + .../lib/graphviz/include/graphviz/dot_builtins.c | 101 +++ .../dist/lib/graphviz/include/graphviz/geom.h | 79 ++ .../dist/lib/graphviz/include/graphviz/graph.h | 222 +++++ .../dist/lib/graphviz/include/graphviz/gv.cpp | 936 +++++++++++++++++++++ .../dist/lib/graphviz/include/graphviz/gv.i | 388 +++++++++ .../dist/lib/graphviz/include/graphviz/gvc.h | 113 +++ .../dist/lib/graphviz/include/graphviz/gvcext.h | 83 ++ .../dist/lib/graphviz/include/graphviz/gvcjob.h | 379 +++++++++ .../dist/lib/graphviz/include/graphviz/gvcommon.h | 42 + .../dist/lib/graphviz/include/graphviz/gvplugin.h | 67 ++ .../graphviz/include/graphviz/gvplugin_device.h | 37 + .../graphviz/include/graphviz/gvplugin_layout.h | 36 + .../graphviz/include/graphviz/gvplugin_loadimage.h | 41 + .../graphviz/include/graphviz/gvplugin_render.h | 71 ++ .../include/graphviz/gvplugin_textlayout.h | 36 + .../graphviz/include/graphviz/no_demand_loading.c | 17 + .../dist/lib/graphviz/include/graphviz/pack.h | 66 ++ .../dist/lib/graphviz/include/graphviz/pathgeom.h | 54 ++ .../dist/lib/graphviz/include/graphviz/pathplan.h | 55 ++ .../dist/lib/graphviz/include/graphviz/textpara.h | 49 ++ .../dist/lib/graphviz/include/graphviz/types.h | 612 ++++++++++++++ .../dist/lib/graphviz/include/graphviz/usershape.h | 59 ++ .../TestApp/dist/lib/graphviz/include/ltdl.h | 366 ++++++++ 28 files changed, 4788 insertions(+) create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/arith.h create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/cdt.h create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/cgraph.h create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/color.h create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/demand_loading.c create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/dot_builtins.c create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/geom.h create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/graph.h create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gv.cpp create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gv.i create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvc.h create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvcext.h create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvcjob.h create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvcommon.h create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvplugin.h create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvplugin_device.h create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvplugin_layout.h create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvplugin_loadimage.h create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvplugin_render.h create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/gvplugin_textlayout.h create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/no_demand_loading.c create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/pack.h create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/pathgeom.h create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/pathplan.h create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/textpara.h create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/types.h create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/graphviz/usershape.h create mode 100644 Master/Agile Software Development/TestApp/dist/lib/graphviz/include/ltdl.h (limited to 'Master/Agile Software Development/TestApp/dist/lib/graphviz/include') 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 +#ifdef HAVE_VALUES_H +#include +#endif +#include + +#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 + +#if _PACKAGE_ast +# include +#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 + +#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 +#else +#include +#include +#endif +#include +#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 +#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 +#include +#include + +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 + 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 /* 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 */ -- cgit v1.2.3