/* initGraphAttrs:
* Set attributes based on original root graph.
* This is obtained by taking a node of g, finding its node
* in the original graph, and finding that node's graph.
*/
static void initGraphAttrs(Agraph_t * g, circ_state * state)
{
static Agraph_t *rootg;
static attrsym_t *N_artpos;
static attrsym_t *N_root;
static attrsym_t *G_mindist;
static char *rootname;
Agraph_t *rg;
node_t *n = agfstnode(g);
rg = agraphof(ORIGN(n));
if (rg != rootg) { /* new root graph */
state->blockCount = 0;
rootg = rg;
G_mindist = agattr(rootg,AGRAPH, "mindist", NULL);
N_artpos = agattr(rootg,AGNODE, "articulation_pos", NULL);
N_root = agattr(rootg,AGNODE, "root", NULL);
}
rootname = agget(rootg, "root");
initBlocklist(&state->bl);
state->orderCount = 1;
state->min_dist = late_double(rootg, G_mindist, MINDIST, 0.0);
state->N_artpos = N_artpos;
state->N_root = N_root;
state->rootname = rootname;
}
/* safe_dcl:
* Find the attribute belonging to graph g for objects like obj
* with given name. If one does not exist, create it with the
* default value def.
*/
attrsym_t*
safe_dcl(graph_t * g, int obj_kind, char *name, char *def)
{
attrsym_t *a = agattr(g,obj_kind,name, NULL);
if (!a) /* attribute does not exist */
a = agattr(g,obj_kind,name,def);
return a;
}
static void addRevEdge(Agraph_t * g, Agedge_t * e)
{
Agsym_t* sym;
Agedge_t* f = agedge (g, aghead(e), agtail(e), agnameof(e), 1);
agcopyattr (;
sym = agattr (g, AGEDGE, TAILPORT_ID, 0);
if (sym) agsafeset (f, HEADPORT_ID, agxget (e, sym), "");
sym = agattr (g, AGEDGE, HEADPORT_ID, 0);
if (sym) agsafeset (f, TAILPORT_ID, agxget (e, sym), "");
}
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");
}
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);
}
}
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);
}
/* 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;
}
void change_selected_graph_attributes(Agraph_t * g, char *attrname,
char *attrvalue)
{
agattr(g, AGRAPH, attrname, "");
agset(view->g[view->activeGraph], attrname, attrvalue);
}
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++;
}
}
}
static void pre(Agraph_t * g)
{
len_sym = agattr(g, AGEDGE, "len", NULL);
aginit(g, AGNODE, "dijkstra", sizeof(nodedata_t), 1);
#if 0
aginit(g, AGEDGE, "dijkstra", sizeof(edgedata_t), 1);
#endif
}
GVC_t *gvContextPlugins(const lt_symlist_t *builtins, int demand_loading)
{
GVC_t *gvc;
agattr(NULL, AGNODE, "label", NODENAME_ESC);
gvc = gvNEWcontext(builtins, demand_loading);
gvconfig(gvc, FALSE); /* configure for available plugins */
return gvc;
}
void init_graph(Agraph_t* g)
{
int i = 0;
Agnode_t* n;
weight = agattr(g, AGEDGE, "weight", "1.0");
pos = agattr(g, AGNODE, "pos", "");
color = agattr(g, AGNODE, "color", "black");
comment = agattr(g, AGRAPH, "cmd", "");
nodes = (Agnode_t**) malloc(sizeof(Agnode_t*)*agnnodes(g));
for(n = agfstnode(g); n; n = agnxtnode(g,n)) {
agbindrec(n, (char*)"nodedata", sizeof(nodedata_t),1);
setid(n,i);
nodes[i] = n;
i++;
}
}
GVC_t *gvContext(void)
{
GVC_t *gvc;
agattr(NULL, AGNODE, "label", NODENAME_ESC);
/* default to no builtins, demand loading enabled */
gvc = gvNEWcontext(NULL, TRUE);
gvconfig(gvc, FALSE); /* configure for available plugins */
return gvc;
}
void change_selected_node_attributes(Agraph_t * g, char *attrname,
char *attrvalue)
{
int ind = 0;
agattr(g, AGNODE, attrname, "");
for (ind = 0; ind < GD_selectedNodesCount(g); ind++) {
agset(GD_selectedNodes(g)[ind], attrname, attrvalue);
}
}
/* 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;
}
char *setv(Agnode_t *n, char *attr, char *val)
{
Agraph_t *g;
Agsym_t *a;
if (!n || !attr || !val)
return NULL;
if (AGTYPE(n) == AGRAPH) { // protonode
g = (Agraph_t*)n;
a = agattr(g, AGNODE, attr, val); // create default attribute in psuodo protonode
// FIXME? - deal with html in "label" attributes
return val;
}
g = agroot(agraphof(n));
a = agattr(g, AGNODE, attr, NULL);
if (!a)
a = agnodeattr(g, attr, emptystring);
myagxset(n, a, val);
return val;
}
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]);
}
}
char *setv(Agedge_t *e, char *attr, char *val)
{
Agraph_t *g;
Agsym_t *a;
if (!e || !attr || !val)
return NULL;
if (AGTYPE(e) == AGRAPH) { // protoedge
g = (Agraph_t*)e;
a = agattr(g, AGEDGE, attr, val); // create default attribute in pseudo protoedge
// FIXME? - deal with html in "label" attributes
return val;
}
g = agroot(agraphof(agtail(e)));
a = agattr(g, AGEDGE, attr, NULL);
if (!a)
a = agattr(g, AGEDGE, attr, emptystring);
myagxset(e, a, val);
return val;
}
void change_selected_graph_attributes(Agraph_t * g, char *attrname,
char *attrvalue)
{
int ind = 0;
agattr(g, AGRAPH, attrname, "");
for (ind = 0; ind < GD_selectedGraphsCount(g); ind++) {
agset(GD_selectedGraphs(g)[ind], attrname, attrvalue);
}
}
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;
}
char *getv(Agnode_t *n, char *attr)
{
Agraph_t *g;
Agsym_t *a;
if (!n || !attr)
return NULL;
if (AGTYPE(n) == AGRAPH) // protonode
return NULL; // FIXME ??
g = agroot(agraphof(n));
a = agattr(g, AGNODE, attr, NULL);
return myagxget(n, a);
}
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++;
}
}
}
char *getv(Agedge_t *e, char *attr)
{
Agraph_t *g;
Agsym_t *a;
if (!e || !attr)
return NULL;
if (AGTYPE(e) == AGRAPH) // protoedge
return NULL; // FIXME ??
g = agraphof(agtail(e));
a = agattr(g, AGEDGE, attr, NULL);
return myagxget(e, a);
}
GVC_t *gvContextPlugins(const lt_symlist_t *builtins, int demand_loading)
{
GVC_t *gvc;
#ifndef WITH_CGRAPH
aginit();
agnodeattr(NULL, "label", NODENAME_ESC);
#else
agattr(NULL, AGNODE, "label", NODENAME_ESC);
#endif
gvc = gvNEWcontext(builtins, demand_loading);
gvconfig(gvc, FALSE); /* configure for available plugins */
return gvc;
}
GVC_t *gvContext(void)
{
GVC_t *gvc;
#ifndef WITH_CGRAPH
aginit();
agnodeattr(NULL, "label", NODENAME_ESC);
#else
agattr(NULL, AGNODE, "label", NODENAME_ESC);
#endif
/* default to no builtins, demand loading enabled */
gvc = gvNEWcontext(NULL, TRUE);
gvconfig(gvc, FALSE); /* configure for available plugins */
return gvc;
}
//------------------------------------------------------------------------------
grafo le_grafo(FILE *input) {
Agraph_t *g;
grafo grafo_lido;
char peso_string[] = "peso";
/* Aloca estrutura do grafo lido */
grafo_lido = (grafo) malloc(sizeof(struct grafo));
if(grafo_lido != NULL) {
/* Armazena em g o grafo lido da entrada */
if((g = agread(input, NULL)) == NULL) {
destroi_grafo(grafo_lido);
return NULL;
}
/* Carrega na estrutura os vértices de g */
if((grafo_lido->grafo_vertices = obter_vertices(g, &(grafo_lido->grafo_n_vertices))) == NULL) {
agclose(g);
destroi_grafo(grafo_lido);
return NULL;
}
/* Verifica se g é um grafo ponderado ou não */
if(agattr(g, AGEDGE, peso_string, (char *) NULL) != NULL) {
grafo_lido->grafo_ponderado = 1;
} else {
grafo_lido->grafo_ponderado = 0;
}
/* Define o nome do grafo e se ele é direcionado */
grafo_lido->grafo_direcionado = agisdirected(g);
grafo_lido->grafo_nome = strdup(agnameof(g));
/* Carrega na estrutura a matriz de adjacência de g */
if((grafo_lido->grafo_matriz = obter_matriz_adjacencia(g, grafo_lido->grafo_vertices, grafo_lido->grafo_ponderado, grafo_lido->grafo_direcionado, grafo_lido->grafo_n_vertices)) == NULL) {
agclose(g);
destroi_grafo(grafo_lido);
return NULL;
}
agclose(g);
}
return grafo_lido;
}
/* 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;
}
/* dot1_rank:
* asp != NULL => g is root
*/
static void dot1_rank(graph_t * g, aspect_t* asp)
{
point p;
#ifdef ALLOW_LEVELS
attrsym_t* N_level;
#endif
edgelabel_ranks(g);
if (asp) {
init_UF_size(g);
initEdgeTypes(g);
}
collapse_sets(g,g);
/*collapse_leaves(g); */
class1(g);
p = minmax_edges(g);
decompose(g, 0);
if (asp && ((GD_comp(g).size > 1)||(GD_n_cluster(g) > 0))) {
asp->badGraph = 1;
asp = NULL;
}
acyclic(g);
if (minmax_edges2(g, p))
decompose(g, 0);
#ifdef ALLOW_LEVELS
if ((N_level = agattr(g,AGNODE,"level",NULL)))
setRanks(g, N_level);
else
#endif
if (asp)
rank3(g, asp);
else
rank1(g);
expand_ranksets(g, asp);
cleanup1(g);
}
main()
{
Agraph_t *g;
Agnode_t *n;
Agedge_t *e;
Agsym_t *sym;
char *val;
while (g = agread(stdin, NIL(Agdisc_t *))) {
#ifdef NOTDEF
for (n = agfstnode(g); n; n = agnxtnode(g, n)) {
fprintf(stderr, "%s\n", agnameof(n));
for (sym = agnxtattr(g, AGNODE, 0); sym;
sym = agnxtattr(g, AGNODE, sym)) {
val = agxget(n, sym);
fprintf(stderr, "\t%s=%s\n", sym->name, val);
}
}
#endif
sym = agattr(g, AGRAPH, "nonsense", "junk");
fprintf(stderr,"sym = %x, %s\n", sym, sym? sym->defval : "(none)");
agwrite(g, stdout);
}
}
/*
cgraph requires
*/
void graph_init(graph_t * g, boolean use_rankdir)
{
char *p;
double xf;
static char *rankname[] = { "local", "global", "none", NULL };
static int rankcode[] = { LOCAL, GLOBAL, NOCLUST, LOCAL };
static char *fontnamenames[] = {"gd","ps","svg", NULL};
static int fontnamecodes[] = {NATIVEFONTS,PSFONTS,SVGFONTS,-1};
int rankdir;
GD_drawing(g) = NEW(layout_t);
/* set this up fairly early in case any string sizes are needed */
if ((p = agget(g, "fontpath")) || (p = getenv("DOTFONTPATH"))) {
/* overide GDFONTPATH in local environment if dot
* wants its own */
#ifdef HAVE_SETENV
setenv("GDFONTPATH", p, 1);
#else
static char *buf = 0;
buf = grealloc(buf, strlen("GDFONTPATH=") + strlen(p) + 1);
strcpy(buf, "GDFONTPATH=");
strcat(buf, p);
putenv(buf);
#endif
}
GD_charset(g) = findCharset (g);
if (!HTTPServerEnVar) {
Gvimagepath = agget (g, "imagepath");
if (!Gvimagepath)
Gvimagepath = Gvfilepath;
}
GD_drawing(g)->quantum =
late_double(g, agfindgraphattr(g, "quantum"), 0.0, 0.0);
/* setting rankdir=LR is only defined in dot,
* but having it set causes shape code and others to use it.
* The result is confused output, so we turn it off unless requested.
* This effective rankdir is stored in the bottom 2 bits of g->u.rankdir.
* Sometimes, the code really needs the graph's rankdir, e.g., neato -n
* with record shapes, so we store the real rankdir in the next 2 bits.
*/
rankdir = RANKDIR_TB;
if ((p = agget(g, "rankdir"))) {
if (streq(p, "LR"))
rankdir = RANKDIR_LR;
else if (streq(p, "BT"))
rankdir = RANKDIR_BT;
else if (streq(p, "RL"))
rankdir = RANKDIR_RL;
}
if (use_rankdir)
SET_RANKDIR (g, (rankdir << 2) | rankdir);
else
SET_RANKDIR (g, (rankdir << 2));
xf = late_double(g, agfindgraphattr(g, "nodesep"),
DEFAULT_NODESEP, MIN_NODESEP);
GD_nodesep(g) = POINTS(xf);
p = late_string(g, agfindgraphattr(g, "ranksep"), NULL);
if (p) {
if (sscanf(p, "%lf", &xf) == 0)
xf = DEFAULT_RANKSEP;
else {
if (xf < MIN_RANKSEP)
xf = MIN_RANKSEP;
}
if (strstr(p, "equally"))
GD_exact_ranksep(g) = TRUE;
} else
xf = DEFAULT_RANKSEP;
GD_ranksep(g) = POINTS(xf);
GD_showboxes(g) = late_int(g, agfindgraphattr(g, "showboxes"), 0, 0);
p = late_string(g, agfindgraphattr(g, "fontnames"), NULL);
GD_fontnames(g) = maptoken(p, fontnamenames, fontnamecodes);
setRatio(g);
GD_drawing(g)->filled =
getdoubles2ptf(g, "size", &(GD_drawing(g)->size));
getdoubles2ptf(g, "page", &(GD_drawing(g)->page));
GD_drawing(g)->centered = mapbool(agget(g, "center"));
if ((p = agget(g, "rotate")))
GD_drawing(g)->landscape = (atoi(p) == 90);
else if ((p = agget(g, "orientation")))
GD_drawing(g)->landscape = ((p[0] == 'l') || (p[0] == 'L'));
else if ((p = agget(g, "landscape")))
GD_drawing(g)->landscape = mapbool(p);
p = agget(g, "clusterrank");
CL_type = maptoken(p, rankname, rankcode);
p = agget(g, "concentrate");
Concentrate = mapbool(p);
State = GVBEGIN;
EdgeLabelsDone = 0;
GD_drawing(g)->dpi = 0.0;
if (((p = agget(g, "dpi")) && p[0])
|| ((p = agget(g, "resolution")) && p[0]))
GD_drawing(g)->dpi = atof(p);
do_graph_label(g);
Initial_dist = MYHUGE;
G_ordering = agfindgraphattr(g, "ordering");
G_gradientangle = agfindgraphattr(g,"gradientangle");
G_margin = agfindgraphattr(g, "margin");
/* initialize nodes */
N_height = agfindnodeattr(g, "height");
N_width = agfindnodeattr(g, "width");
N_shape = agfindnodeattr(g, "shape");
N_color = agfindnodeattr(g, "color");
N_fillcolor = agfindnodeattr(g, "fillcolor");
N_style = agfindnodeattr(g, "style");
N_fontsize = agfindnodeattr(g, "fontsize");
N_fontname = agfindnodeattr(g, "fontname");
N_fontcolor = agfindnodeattr(g, "fontcolor");
N_label = agfindnodeattr(g, "label");
if (!N_label)
N_label = agattr(g, AGNODE, "label", NODENAME_ESC);
N_xlabel = agfindnodeattr(g, "xlabel");
N_showboxes = agfindnodeattr(g, "showboxes");
N_penwidth = agfindnodeattr(g, "penwidth");
N_ordering = agfindnodeattr(g, "ordering");
N_margin = agfindnodeattr(g, "margin");
/* attribs for polygon shapes */
N_sides = agfindnodeattr(g, "sides");
N_peripheries = agfindnodeattr(g, "peripheries");
N_skew = agfindnodeattr(g, "skew");
N_orientation = agfindnodeattr(g, "orientation");
N_distortion = agfindnodeattr(g, "distortion");
N_fixed = agfindnodeattr(g, "fixedsize");
N_imagescale = agfindnodeattr(g, "imagescale");
N_nojustify = agfindnodeattr(g, "nojustify");
N_layer = agfindnodeattr(g, "layer");
N_group = agfindnodeattr(g, "group");
N_comment = agfindnodeattr(g, "comment");
N_vertices = agfindnodeattr(g, "vertices");
N_z = agfindnodeattr(g, "z");
N_gradientangle = agfindnodeattr(g,"gradientangle");
/* initialize edges */
E_weight = agfindedgeattr(g, "weight");
E_color = agfindedgeattr(g, "color");
E_fillcolor = agfindedgeattr(g, "fillcolor");
E_fontsize = agfindedgeattr(g, "fontsize");
E_fontname = agfindedgeattr(g, "fontname");
E_fontcolor = agfindedgeattr(g, "fontcolor");
E_label = agfindedgeattr(g, "label");
E_xlabel = agfindedgeattr(g, "xlabel");
E_label_float = agfindedgeattr(g, "labelfloat");
/* vladimir */
E_dir = agfindedgeattr(g, "dir");
E_arrowhead = agfindedgeattr(g, "arrowhead");
E_arrowtail = agfindedgeattr(g, "arrowtail");
E_headlabel = agfindedgeattr(g, "headlabel");
E_taillabel = agfindedgeattr(g, "taillabel");
E_labelfontsize = agfindedgeattr(g, "labelfontsize");
E_labelfontname = agfindedgeattr(g, "labelfontname");
E_labelfontcolor = agfindedgeattr(g, "labelfontcolor");
E_labeldistance = agfindedgeattr(g, "labeldistance");
E_labelangle = agfindedgeattr(g, "labelangle");
/* end vladimir */
E_minlen = agfindedgeattr(g, "minlen");
E_showboxes = agfindedgeattr(g, "showboxes");
E_style = agfindedgeattr(g, "style");
E_decorate = agfindedgeattr(g, "decorate");
E_arrowsz = agfindedgeattr(g, "arrowsize");
E_constr = agfindedgeattr(g, "constraint");
E_layer = agfindedgeattr(g, "layer");
E_comment = agfindedgeattr(g, "comment");
E_tailclip = agfindedgeattr(g, "tailclip");
E_headclip = agfindedgeattr(g, "headclip");
E_penwidth = agfindedgeattr(g, "penwidth");
/* background */
GD_drawing(g)->xdots = init_xdot (g);
/* initialize id, if any */
if ((p = agget(g, "id")) && *p)
GD_drawing(g)->id = strdup_and_subst_obj(p, g);
}
