/* copyAttr:
* Copy attributes from src to tgt. Overrides currently
* defined values.
* FIX: we should probably use the default value of the source
* graph when initializing the attribute, rather than "".
* NOTE: We do not assume src and tgt have the same kind.
*/
int copyAttr(Agobj_t * src, Agobj_t * tgt)
{
Agraph_t *srcg;
Agraph_t *tgtg;
Agsym_t *sym = 0;
Agsym_t *tsym = 0;
int skind = AGTYPE(src);
int tkind = AGTYPE(tgt);
char* val;
srcg = agraphof(src);
tgtg = agraphof(tgt);
while ((sym = agnxtattr(srcg, skind, sym))) {
tsym = agattrsym(tgt, sym->name);
if (!tsym)
tsym = agattr(tgtg, tkind, sym->name, sym->defval);
val = agxget(src, sym);
if (aghtmlstr (val)) {
val = agstrdup_html (tgtg, val);
agxset(tgt, tsym, val);
agstrfree (tgtg, val);
}
else
agxset(tgt, tsym, val);
}
return 0;
}
static void attr_set(char *name, char *value)
{
Agsym_t *ap = NULL;
char *defval = "";
if (In_decl && (G->root == G)) defval = value;
switch (Current_class) {
case TAG_NODE:
ap = agfindattr(G->proto->n,name);
if (ap == NULL)
ap = agnodeattr(AG.parsed_g,name,defval);
else if (ap->fixed && In_decl)
return;
agxset(N,ap->index,value);
break;
case TAG_EDGE:
ap = agfindattr(G->proto->e,name);
if (ap == NULL)
ap = agedgeattr(AG.parsed_g,name,defval);
else if (ap->fixed && In_decl)
return;
agxset(E,ap->index,value);
break;
case 0: /* default */
case TAG_GRAPH:
ap = agfindattr(G,name);
if (ap == NULL)
ap = agraphattr(AG.parsed_g,name,defval);
else if (ap->fixed && In_decl)
return;
agxset(G,ap->index,value);
break;
}
}
static void xdot_end_node(GVJ_t* job)
{
Agnode_t* n = job->obj->u.n;
if (agxblen(xbufs[EMIT_NDRAW]))
agxset(n, xd->n_draw, agxbuse(xbufs[EMIT_NDRAW]));
if (agxblen(xbufs[EMIT_NLABEL]))
agxset(n, xd->n_l_draw, agxbuse(xbufs[EMIT_NLABEL]));
penwidth[EMIT_NDRAW] = 1;
penwidth[EMIT_NLABEL] = 1;
textflags[EMIT_NDRAW] = 0;
textflags[EMIT_NLABEL] = 0;
}
static void xdot_end_cluster(GVJ_t * job)
{
Agraph_t* cluster_g = job->obj->u.sg;
agxset(cluster_g, xd->g_draw, agxbuse(xbufs[EMIT_CDRAW]));
if (GD_label(cluster_g))
agxset(cluster_g, xd->g_l_draw, agxbuse(xbufs[EMIT_CLABEL]));
penwidth[EMIT_CDRAW] = 1;
penwidth[EMIT_CLABEL] = 1;
textflags[EMIT_CDRAW] = 0;
textflags[EMIT_CLABEL] = 0;
}
static void post(Agraph_t * g)
{
Agnode_t *v;
Agnode_t *prev;
char buf[256];
char dflt[256];
Agsym_t *sym;
Agsym_t *psym;
double dist, oldmax;
double maxdist = 0.0; /* maximum "finite" distance */
sym = agattr(g, AGNODE, "dist", "");
if (doPath)
psym = agattr(g, AGNODE, "prev", "");
if (setall)
sprintf(dflt, "%.3lf", HUGE);
for (v = agfstnode(g); v; v = agnxtnode(g, v)) {
dist = getdist(v);
if (dist) {
dist--;
sprintf(buf, "%.3lf", dist);
agxset(v, sym, buf);
if (doPath && (prev = getprev(v)))
agxset(v, psym, agnameof(prev));
if (maxdist < dist)
maxdist = dist;
} else if (setall)
agxset(v, sym, dflt);
}
sym = agattrsym(g, "maxdist");
if (sym) {
if (!setall) {
/* if we are preserving distances in other components,
* check previous value of maxdist.
*/
oldmax = atof(agxget(g, sym));
if (oldmax > maxdist)
maxdist = oldmax;
}
sprintf(buf, "%.3lf", maxdist);
agxset(g, sym, buf);
} else {
sprintf(buf, "%.3lf", maxdist);
agattr(g, AGRAPH, "maxdist", buf);
}
agclean(g, AGNODE, "dijkstra");
agclean(g, AGEDGE, "dijkstra");
}
/* constrainY:
* See constrainX.
*/
static void constrainY(graph_t* g, nitem* nlist, int nnodes, intersectfn ifn,
int ortho)
{
Dt_t *list = dtopen(&constr, Dtobag);
nitem *p = nlist;
graph_t *cg;
int i;
for (i = 0; i < nnodes; i++) {
p->val = p->pos.y;
dtinsert(list, p);
p++;
}
if (ortho)
cg = mkConstraintG(g, list, ifn, distY);
else
cg = mkNConstraintG(g, list, ifn, distY);
rank(cg, 2, INT_MAX);
#ifdef DEBUG
{
Agsym_t *mlsym = agedgeattr(cg, "minlen", "");
Agsym_t *rksym = agnodeattr(cg, "rank", "");
char buf[100];
node_t *n;
edge_t *e;
for (n = agfstnode(cg); n; n = agnxtnode(cg, n)) {
sprintf(buf, "%d", ND_rank(n));
agxset(n, rksym->index, buf);
for (e = agfstedge(cg, n); e; e = agnxtedge(cg, e, n)) {
sprintf(buf, "%d", ED_minlen(e));
agxset(e, mlsym->index, buf);
}
}
}
#endif
p = nlist;
for (i = 0; i < nnodes; i++) {
int newpos, oldpos, delta;
oldpos = p->pos.y;
newpos = ND_rank(p->cnode);
delta = newpos - oldpos;
p->pos.y = newpos;
p->bb.LL.y += delta;
p->bb.UR.y += delta;
p++;
}
closeGraph(cg);
dtclose(list);
}
static void adjustlen(Agedge_t * e, Agsym_t * sym, int newlen)
{
char buf[10];
sprintf(buf, "%d", newlen);
agxset(e, sym, buf);
}
/* mapN:
* Convert cluster nodes back to ordinary nodes
* If n is already ordinary, return it.
* Otherwise, we know node's name is "__i:xxx"
* where i is some number and xxx is the nodes's original name.
* Create new node of name xxx if it doesn't exist and add n to clg
* for later deletion.
*/
static node_t *mapN(node_t * n, graph_t * clg)
{
node_t *nn;
char *name;
graph_t *g = agraphof(n);
Agsym_t *sym;
if (!(IS_CLUST_NODE(n)))
return n;
agsubnode(clg, n, 1);
name = strchr(agnameof(n), ':');
assert(name);
name++;
if ((nn = agfindnode(g, name)))
return nn;
nn = agnode(g, name, 1);
agbindrec(nn, "Agnodeinfo_t", sizeof(Agnodeinfo_t), TRUE);
/* Set all attributes to default */
for (sym = agnxtattr(g, AGNODE, NULL); sym; (sym = agnxtattr(g, AGNODE, sym))) {
if (agxget(nn, sym) != sym->defval)
agxset(nn, sym, sym->defval);
}
return nn;
}
/* mapN:
* Convert cluster nodes back to ordinary nodes
* If n is already ordinary, return it.
* Otherwise, we know node's name is "__i:xxx"
* where i is some number and xxx is the nodes's original name.
* Create new node of name xxx if it doesn't exist and add n to clg
* for later deletion.
*/
static node_t *mapN(node_t * n, graph_t * clg)
{
extern Agdict_t *agdictof(void *);
node_t *nn;
char *name;
graph_t *g = n->graph;
Agdict_t *d;
Agsym_t **list;
Agsym_t *sym;
if (!(IS_CLUST_NODE(n)))
return n;
aginsert(clg, n);
name = strchr(n->name, ':');
assert(name);
name++;
if ((nn = agfindnode(g, name)))
return nn;
nn = agnode(g, name);
/* Set all attributes to default */
d = agdictof(n);
list = d->list;
while ((sym = *list++)) {
/* Can use pointer comparison because of ref strings. */
if (agxget(nn, sym->index) != sym->value)
agxset(nn, sym->index, sym->value);
}
return nn;
}
static void xdot_end_cluster(GVJ_t * job)
{
Agraph_t* cluster_g = job->obj->u.sg;
#ifndef WITH_CGRAPH
agxset(cluster_g, xd->g_draw->index, agxbuse(xbufs[EMIT_CDRAW]));
#else /* WITH_CGRAPH */
agxset(cluster_g, xd->g_draw, agxbuse(xbufs[EMIT_CDRAW]));
#endif /* WITH_CGRAPH */
if (GD_label(cluster_g))
#ifndef WITH_CGRAPH
agxset(cluster_g, xd->g_l_draw->index, agxbuse(xbufs[EMIT_CLABEL]));
#else /* WITH_CGRAPH */
agxset(cluster_g, xd->g_l_draw, agxbuse(xbufs[EMIT_CLABEL]));
#endif /* WITH_CGRAPH */
penwidth[EMIT_CDRAW] = 1;
penwidth[EMIT_CLABEL] = 1;
}
static void xdot_end_node(GVJ_t* job)
{
Agnode_t* n = job->obj->u.n;
if (agxblen(xbufs[EMIT_NDRAW]))
#ifndef WITH_CGRAPH
agxset(n, xd->n_draw->index, agxbuse(xbufs[EMIT_NDRAW]));
#else /* WITH_CGRAPH */
agxset(n, xd->n_draw, agxbuse(xbufs[EMIT_NDRAW]));
#endif /* WITH_CGRAPH */
if (agxblen(xbufs[EMIT_NLABEL]))
#ifndef WITH_CGRAPH
agxset(n, xd->n_l_draw->index, agxbuse(xbufs[EMIT_NLABEL]));
#else /* WITH_CGRAPH */
agxset(n, xd->n_l_draw, agxbuse(xbufs[EMIT_NLABEL]));
#endif /* WITH_CGRAPH */
penwidth[EMIT_NDRAW] = 1;
penwidth[EMIT_NLABEL] = 1;
}
void setgraphattributes(Agraph_t * g, char *argv[], int argc)
{
int i;
Agsym_t *a;
for (i = 0; i < argc; i++) {
if (!(a = agfindgraphattr(agroot(g), argv[i])))
a = agattr(agroot(g), AGRAPH, argv[i], "");
agxset(g, a, argv[++i]);
}
}
static void transform(Agraph_t * g)
{
Agnode_t *n;
Agedge_t *e;
char *str;
Agsym_t *m_ix, *s_ix;
int cnt, d;
m_ix = bindedgeattr(g, "minlen");
s_ix = bindedgeattr(g, "style");
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
d = myindegree(n) + myoutdegree(n);
if (d == 0) {
if (ChainLimit < 1)
continue;
if (ChainNode) {
e = agedge(g, ChainNode, n, "", TRUE);
agxset(e, s_ix, "invis");
ChainSize++;
if (ChainSize < ChainLimit)
ChainNode = n;
else {
ChainNode = NULL;
ChainSize = 0;
}
} else
ChainNode = n;
} else if (d > 1) {
if (MaxMinlen < 1)
continue;
cnt = 0;
for (e = agfstin(g, n); e; e = agnxtin(g, e)) {
if (isleaf(agtail(e))) {
str = agxget(e, m_ix);
if (str[0] == 0) {
adjustlen(e, m_ix, (cnt % MaxMinlen) + 1);
cnt++;
}
}
}
cnt = 0;
for (e = agfstout(g, n); e; e = agnxtout(g, e)) {
if (isleaf(e->node) || (Do_fans && ischainnode(e->node))) {
str = agxget(e, m_ix);
if (str[0] == 0)
adjustlen(e, m_ix, (cnt % MaxMinlen) + 1);
cnt++;
}
}
}
}
}
static void xdot_end_graph(graph_t* g)
{
int i;
if (agxblen(xbufs[EMIT_GDRAW])) {
if (!xd->g_draw)
xd->g_draw = safe_dcl(g, AGRAPH, "_draw_", "");
agxset(g, xd->g_draw, agxbuse(xbufs[EMIT_GDRAW]));
}
if (GD_label(g))
agxset(g, xd->g_l_draw, agxbuse(xbufs[EMIT_GLABEL]));
agsafeset (g, "xdotversion", xd->version_s, "");
for (i = 0; i < NUMXBUFS; i++)
agxbfree(xbuf+i);
free (xd);
penwidth[EMIT_GDRAW] = 1;
penwidth[EMIT_GLABEL] = 1;
textflags[EMIT_GDRAW] = 0;
textflags[EMIT_GLABEL] = 0;
}
static void xdot_end_edge(GVJ_t* job)
{
Agedge_t* e = job->obj->u.e;
if (agxblen(xbufs[EMIT_EDRAW]))
agxset(e, xd->e_draw, agxbuse(xbufs[EMIT_EDRAW]));
if (agxblen(xbufs[EMIT_TDRAW]))
agxset(e, xd->t_draw, agxbuse(xbufs[EMIT_TDRAW]));
if (agxblen(xbufs[EMIT_HDRAW]))
agxset(e, xd->h_draw, agxbuse(xbufs[EMIT_HDRAW]));
if (agxblen(xbufs[EMIT_ELABEL]))
agxset(e, xd->e_l_draw,agxbuse(xbufs[EMIT_ELABEL]));
if (agxblen(xbufs[EMIT_TLABEL]))
agxset(e, xd->tl_draw, agxbuse(xbufs[EMIT_TLABEL]));
if (agxblen(xbufs[EMIT_HLABEL]))
agxset(e, xd->hl_draw, agxbuse(xbufs[EMIT_HLABEL]));
penwidth[EMIT_EDRAW] = 1;
penwidth[EMIT_ELABEL] = 1;
penwidth[EMIT_TDRAW] = 1;
penwidth[EMIT_HDRAW] = 1;
penwidth[EMIT_TLABEL] = 1;
penwidth[EMIT_HLABEL] = 1;
textflags[EMIT_EDRAW] = 0;
textflags[EMIT_ELABEL] = 0;
textflags[EMIT_TDRAW] = 0;
textflags[EMIT_HDRAW] = 0;
textflags[EMIT_TLABEL] = 0;
textflags[EMIT_HLABEL] = 0;
}
grafo escreve_grafo(FILE *output, grafo g){
if(!g || !output)
return NULL;
Agraph_t *ag;
Agsym_t *peso;
char peso_s[MAX_STRING_SIZE];
//criando a string "peso"
char p_str[5];
strcpy(p_str, "peso");
//cria uma string vazia pra usar como valor default do atributo peso
char default_s[1];
default_s[0] = '\0';
if(g->direcionado)
ag = agopen(g->nome, Agstrictdirected, NULL);
else
ag= agopen(g->nome, Agstrictundirected, NULL);
if(g->ponderado)
peso = agattr(ag, AGEDGE, p_str, default_s);
Agnode_t **nodes = malloc(g->n_vertices * sizeof(Agnode_t*));
for(unsigned int i = 0; i < g->n_vertices; i++)
nodes[g->vertices[i]->id] = agnode(ag, g->vertices[i]->nome, TRUE);
for(unsigned int i = 0; i < g->n_vertices; i++){
vertice v = g->vertices[i];
for(no n = primeiro_no(v->adjacencias_saida); n != NULL; n = proximo_no(n)){
adjacencia viz = conteudo(n);
Agedge_t *ae = agedge(ag, nodes[v->id], nodes[viz->v_destino->id], NULL, TRUE);
if(g->ponderado){
sprintf(peso_s, "%ld", viz->peso);
agxset(ae, peso, peso_s);
}
}
}
free(nodes);
agwrite(ag, output);
agclose(ag);
agfree(ag, NULL);
return g;
}
static void rec_attach_bb(graph_t * g, Agsym_t* bbsym, Agsym_t* lpsym, Agsym_t* lwsym, Agsym_t* lhsym)
{
int c;
char buf[BUFSIZ];
pointf pt;
sprintf(buf, "%.5g,%.5g,%.5g,%.5g", GD_bb(g).LL.x, YDIR(GD_bb(g).LL.y),
GD_bb(g).UR.x, YDIR(GD_bb(g).UR.y));
agxset(g, bbsym, buf);
if (GD_label(g) && GD_label(g)->text[0]) {
pt = GD_label(g)->pos;
sprintf(buf, "%.5g,%.5g", pt.x, YDIR(pt.y));
agxset(g, lpsym, buf);
pt = GD_label(g)->dimen;
sprintf(buf, "%.2f", PS2INCH(pt.x));
agxset (g, lwsym, buf);
sprintf(buf, "%.2f", PS2INCH(pt.y));
agxset (g, lhsym, buf);
}
for (c = 1; c <= GD_n_cluster(g); c++)
rec_attach_bb(GD_clust(g)[c], bbsym, lpsym, lwsym, lhsym);
}
void change_selected_edge_attributes(Agraph_t * g, char *attrname,
char *attrvalue)
{
int ind = 0;
Agsym_t* ap = agattr(g, AGEDGE, attrname, NULL);
if (!ap)
ap = agattr(g, AGEDGE, attrname, "");
for (ind = 0; ind < view->Topview->Edgecount; ind++) {
if (view->Topview->Edges[ind].data.Selected == 1)
agxset(view->Topview->Edges[ind].Edge, ap, attrvalue);
}
}
int main(int argc, char** argv)
{
Agraph_t *g;
Agnode_t *n,*m;
Agedge_t *e;
Agsym_t *a;
GVC_t *gvc;
/* set up renderer context */
gvc = gvContext();
/* Accept -T and -o options like dot.
* Input files are ignored in this demo. */
dotneato_initialize(gvc, argc,argv);
/* Create a simple digraph */
g = agopen("g",AGDIGRAPH);
n = agnode(g,"n");
m = agnode(g,"m");
e = agedge(g,n,m);
/* Set an attribute - in this case one that affects the visible rendering */
if (!(a = agfindattr(g->proto->n, "color")))
a = agnodeattr(g, "color", "");
agxset(n, a->index, "red");
/* bind graph to GV context - currently must be done before layout */
gvBindContext(gvc,g);
/* Compute a layout */
neato_layout(g);
/* twopi_layout(g); */
/* dot_layout(g); */
/* Write the graph according to -T and -o options */
dotneato_write(gvc);
/* Clean out layout data */
/* neato_cleanup(g); */
/* twopi_cleanup(g); */
/* dot_cleanup(g); */
/* Free graph structures */
agclose(g);
/* Clean up output file and errors */
dotneato_terminate(gvc);
return 1;
}
void tcldot_layout(GVC_t *gvc, Agraph_t * g, char *engine)
{
char buf[256];
Agsym_t *a;
int rc;
gvFreeLayout(gvc, g); /* in case previously drawn */
/* support old behaviors if engine isn't specified*/
if (!engine || *engine == '\0') {
if (agisdirected(g))
rc = gvlayout_select(gvc, "dot");
else
rc = gvlayout_select(gvc, "neato");
}
else {
if (strcasecmp(engine, "nop") == 0) {
Nop = 2;
PSinputscale = POINTS_PER_INCH;
rc = gvlayout_select(gvc, "neato");
}
else {
rc = gvlayout_select(gvc, engine);
}
if (rc == NO_SUPPORT)
rc = gvlayout_select(gvc, "dot");
}
if (rc == NO_SUPPORT) {
fprintf(stderr, "Layout type: \"%s\" not recognized. Use one of:%s\n",
engine, gvplugin_list(gvc, API_layout, engine));
return;
}
gvLayoutJobs(gvc, g);
/* set bb attribute for basic layout.
* doesn't yet include margins, scaling or page sizes because
* those depend on the renderer being used. */
if (GD_drawing(g)->landscape)
sprintf(buf, "%d %d %d %d",
ROUND(GD_bb(g).LL.y), ROUND(GD_bb(g).LL.x),
ROUND(GD_bb(g).UR.y), ROUND(GD_bb(g).UR.x));
else
sprintf(buf, "%d %d %d %d",
ROUND(GD_bb(g).LL.x), ROUND(GD_bb(g).LL.y),
ROUND(GD_bb(g).UR.x), ROUND(GD_bb(g).UR.y));
if (!(a = agattr(g, AGRAPH, "bb", NULL)))
a = agattr(g, AGRAPH, "bb", "");
agxset(g, a, buf);
}
gboolean
cls_node_collapse (ClsNode *cls_node)
{
Agsym_t *sym;
if (cls_node->expansion_status == CLS_NODE_COLLAPSED)
return FALSE;
if (!(sym = agfindattr(cls_node->graph->proto->n, "label")))
sym = agnodeattr(cls_node->graph, "label", "");
agxset(cls_node->agnode, sym->index, cls_node->sym_name);
cls_node->expansion_status = CLS_NODE_COLLAPSED;
return TRUE;
}
/*----------------------------------------------------------------------------
* initialize the internal graphviz structure.
*/
static void
cls_inherit_graph_init (AnjutaClassInheritance *plugin, gchar* graph_label)
{
Agsym_t *sym;
gchar dpi_text[16];
snprintf (dpi_text, 16, "%d", INCH_TO_PIXELS_CONVERSION_FACTOR);
aginit ();
plugin->graph = agopen (graph_label, AGDIGRAPH);
plugin->gvc = gvContext();
if (!(sym = agfindattr(plugin->graph->proto->n, "dpi")))
sym = agraphattr(plugin->graph, "dpi", dpi_text);
agxset(plugin->graph, sym->index, dpi_text);
}
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);
}
void setnodeattributes(Agraph_t * g, Agnode_t * n, char *argv[], int argc)
{
int i;
Agsym_t *a;
for (i = 0; i < argc; i++) {
if (n) {
if (!(a = agfindnodeattr(g, argv[i])))
a = agattr(agroot(g), AGNODE, argv[i], "");
agxset(n, a, argv[++i]);
}
else {
agattr(g, AGNODE, argv[i], argv[i+1]);
i++;
}
}
}
/* agcopyattr:
* Assumes attributes have already been declared.
* Do not copy key attribute for edges, as this must be distinct.
* Returns non-zero on failure or if objects have different type.
*/
int agcopyattr(void *oldobj, void *newobj)
{
Agdict_t *d = agdictof(oldobj);
Agsym_t **list = d->list;
Agsym_t *sym;
Agsym_t *newsym;
int r = 0;
int isEdge = (TAG_OF(oldobj) == TAG_EDGE);
if (TAG_OF(oldobj) != TAG_OF(newobj)) return 1;
while (!r && (sym = *list++)) {
if (isEdge && sym->index == KEYX) continue;
newsym = agfindattr(newobj,sym->name);
if (!newsym) return 1;
r = agxset(newobj, newsym->index, agxget(oldobj, sym->index));
}
return r;
}
/* setAttr:
* Sets object's name attribute to the given value.
* Creates the attribute if not already set.
*/
static Agsym_t *setAttr(graph_t * g, void *obj, char *name, char *value,
Agsym_t * ap)
{
if (ap == NULL) {
switch (agobjkind(obj)) {
case AGGRAPH:
ap = agraphattr(g, name, "");
break;
case AGNODE:
ap = agnodeattr(g, name, "");
break;
case AGEDGE:
ap = agedgeattr(g, name, "");
break;
}
}
agxset(obj, ap->index, value);
return ap;
}
/* setAttr:
* Sets object's name attribute to the given value.
* Creates the attribute if not already set.
*/
Agsym_t *setAttr(graph_t * g, void *obj, char *name, char *value,
Agsym_t * ap)
{
if (ap == NULL) {
switch (agobjkind(obj)) {
case AGRAPH:
ap = agattr(g, AGRAPH,name, "");
break;
case AGNODE:
ap = agattr(g,AGNODE, name, "");
break;
case AGEDGE:
ap = agattr(g,AGEDGE, name, "");
break;
}
}
agxset(obj, ap, value);
return ap;
}
/* copyAttr;
* Copy attributes from src to tgt. Overrides currently
* defined values.
* FIX: we should probably use the default value of the source
* graph when initializing the attribute, rather than "".
* NOTE: We do not assume src and tgt have the same kind.
*/
int copyAttr(Agobj_t * src, Agobj_t * tgt)
{
Agraph_t *srcg;
Agraph_t *tgtg;
Agsym_t *sym = 0;
Agsym_t *tsym = 0;
int skind = AGTYPE(src);
int tkind = AGTYPE(tgt);
srcg = agraphof(src);
tgtg = agraphof(tgt);
while ((sym = agnxtattr(srcg, skind, sym))) {
tsym = agattrsym(tgt, sym->name);
if (!tsym)
tsym = agattr(tgtg, tkind, sym->name, "");
agxset(tgt, tsym, agxget(src, sym));
}
return 0;
}
int agsafeset(void* obj, char* name, char* value, char* def)
{
Agsym_t* a = agfindattr(obj, name);
if (a == NULL) {
if (!def) def = "";
switch (TAG_OF(obj)) {
case TAG_GRAPH:
a = agraphattr(((Agraph_t*)obj)->root, name, def);
break;
case TAG_NODE:
a = agnodeattr(((Agnode_t*)obj)->graph, name, def);
break;
case TAG_EDGE:
a = agedgeattr(((Agedge_t*)obj)->head->graph, name, def);
break;
}
}
return agxset(obj, a->index, value);
}
void setedgeattributes(Agraph_t * g, Agedge_t * e, char *argv[], int argc)
{
int i;
Agsym_t *a;
for (i = 0; i < argc; i++) {
/* silently ignore attempts to modify "key" */
if (strcmp(argv[i], "key") == 0) {
i++;
continue;
}
if (e) {
if (!(a = agfindedgeattr(g, argv[i])))
a = agattr(agroot(g), AGEDGE, argv[i], "");
agxset(e, a, argv[++i]);
}
else {
agattr(g, AGEDGE, argv[i], argv[i+1]);
i++;
}
}
}
