static void
dot_init_edge(edge_t * e)
{
char *tailgroup, *headgroup;
#ifdef WITH_CGRAPH
agbindrec(e, "Agedgeinfo_t", sizeof(Agedgeinfo_t), TRUE); //graph custom data
#endif /* WITH_CGRAPH */
common_init_edge(e);
ED_weight(e) = late_double(e, E_weight, 1.0, 0.0);
tailgroup = late_string(agtail(e), N_group, "");
headgroup = late_string(aghead(e), N_group, "");
ED_count(e) = ED_xpenalty(e) = 1;
if (tailgroup[0] && (tailgroup == headgroup)) {
ED_xpenalty(e) = CL_CROSS;
ED_weight(e) *= 100;
}
if (nonconstraint_edge(e)) {
ED_xpenalty(e) = 0;
ED_weight(e) = 0;
}
ED_showboxes(e) = late_int(e, E_showboxes, 0, 0);
ED_minlen(e) = late_int(e, E_minlen, 1, 0);
}
/* tuneControl:
* Use user values to reset control
*
* Possible parameters:
* ctrl->use_node_weights
*/
static void
tuneControl (graph_t* g, spring_electrical_control ctrl)
{
long seed;
int init;
seed = ctrl->random_seed;
init = setSeed (g, INIT_RANDOM, &seed);
if (init != INIT_RANDOM) {
agerr(AGWARN, "sfdp only supports start=random\n");
}
ctrl->random_seed = seed;
ctrl->K = late_double(g, agfindgraphattr(g, "K"), -1.0, 0.0);
ctrl->p = -1.0*late_double(g, agfindgraphattr(g, "repulsiveforce"), -AUTOP, 0.0);
ctrl->multilevels = late_int(g, agfindgraphattr(g, "levels"), INT_MAX, 0);
ctrl->smoothing = late_smooth(g, agfindgraphattr(g, "smoothing"), SMOOTHING_NONE);
ctrl->tscheme = late_quadtree_scheme(g, agfindgraphattr(g, "quadtree"), QUAD_TREE_NORMAL);
/* ctrl->method = late_mode(g, agfindgraphattr(g, "mode"), METHOD_SPRING_ELECTRICAL); */
ctrl->method = METHOD_SPRING_ELECTRICAL;
ctrl->beautify_leaves = mapBool (agget(g, "beautify"), FALSE);
ctrl->rotation = late_double(g, agfindgraphattr(g, "rotation"), 0.0, -MAXDOUBLE);
ctrl->edge_labeling_scheme = late_int(g, agfindgraphattr(g, "label_scheme"), 0, 0);
if (ctrl->edge_labeling_scheme > 4) {
agerr (AGWARN, "label_scheme = %d > 4 : ignoring\n", ctrl->edge_labeling_scheme);
ctrl->edge_labeling_scheme = 0;
}
}
static void sfdp_init_graph(Agraph_t * g)
{
int outdim;
setEdgeType(g, ET_LINE);
outdim = late_int(g, agfindgraphattr(g, "dimen"), 2, 2);
GD_ndim(agroot(g)) = late_int(g, agfindgraphattr(g, "dim"), outdim, 2);
Ndim = GD_ndim(agroot(g)) = MIN(GD_ndim(agroot(g)), MAXDIM);
GD_odim(agroot(g)) = MIN(outdim, Ndim);
sfdp_init_node_edge(g);
}
void common_init_node(node_t * n)
{
struct fontinfo fi;
char *str;
ND_width(n) =
late_double(n, N_width, DEFAULT_NODEWIDTH, MIN_NODEWIDTH);
ND_height(n) =
late_double(n, N_height, DEFAULT_NODEHEIGHT, MIN_NODEHEIGHT);
ND_shape(n) =
bind_shape(late_nnstring(n, N_shape, DEFAULT_NODESHAPE), n);
str = agxget(n, N_label);
fi.fontsize = late_double(n, N_fontsize, DEFAULT_FONTSIZE, MIN_FONTSIZE);
fi.fontname = late_nnstring(n, N_fontname, DEFAULT_FONTNAME);
fi.fontcolor = late_nnstring(n, N_fontcolor, DEFAULT_COLOR);
ND_label(n) = make_label((void*)n, str,
((aghtmlstr(str) ? LT_HTML : LT_NONE) | ( (shapeOf(n) == SH_RECORD) ? LT_RECD : LT_NONE)),
fi.fontsize, fi.fontname, fi.fontcolor);
if (N_xlabel && (str = agxget(n, N_xlabel)) && (str[0])) {
ND_xlabel(n) = make_label((void*)n, str, (aghtmlstr(str) ? LT_HTML : LT_NONE),
fi.fontsize, fi.fontname, fi.fontcolor);
GD_has_labels(agraphof(n)) |= NODE_XLABEL;
}
ND_showboxes(n) = late_int(n, N_showboxes, 0, 0);
ND_shape(n)->fns->initfn(n);
}
static void
dot_init_edge(edge_t * e)
{
char *tailgroup, *headgroup;
common_init_edge(e);
ED_weight(e) = late_double(e, E_weight, 1.0, 0.0);
tailgroup = late_string(e->tail, N_group, "");
headgroup = late_string(e->head, N_group, "");
ED_count(e) = ED_xpenalty(e) = 1;
if (tailgroup[0] && (tailgroup == headgroup)) {
ED_xpenalty(e) = CL_CROSS;
ED_weight(e) *= 100;
}
if (nonconstraint_edge(e)) {
ED_xpenalty(e) = 0;
ED_weight(e) = 0;
}
ED_showboxes(e) = late_int(e, E_showboxes, 0, 0);
ED_minlen(e) = late_int(e, E_minlen, 1, 0);
}
/* init_graph:
* Initialize attributes. We always do the minimum required by
* libcommon. If fill is true, we use init_nop (neato -n) to
* read in attributes relevant to the layout.
*/
static void init_graph(Agraph_t * g, boolean fill)
{
int d;
graph_init(g, FALSE);
d = late_int(g, agfindattr(g, "dim"), 2, 2);
if (d != 2) {
fprintf(stderr, "Error: graph %s has dim = %d (!= 2)\n", g->name,
d);
exit(1);
}
Ndim = GD_ndim(g) = 2;
init_node_edge(g);
if (fill && init_nop(g, 0)) {
exit(1);
}
}
static void dotLayout(Agraph_t * g)
{
aspect_t aspect;
aspect_t* asp;
int maxphase = late_int(g, agfindgraphattr(g,"phase"), -1, 1);
setEdgeType (g, ET_SPLINE);
asp = setAspect (g, &aspect);
dot_init_subg(g,g);
dot_init_node_edge(g);
do {
dot_rank(g, asp);
if (maxphase == 1) {
attach_phase_attrs (g, 1);
return;
}
if (aspect.badGraph) {
agerr(AGWARN, "dot does not support the aspect attribute for disconnected graphs or graphs with clusters\n");
asp = NULL;
aspect.nextIter = 0;
}
dot_mincross(g, (asp != NULL));
if (maxphase == 2) {
attach_phase_attrs (g, 2);
return;
}
dot_position(g, asp);
if (maxphase == 3) {
attach_phase_attrs (g, 2); /* positions will be attached on output */
return;
}
aspect.nPasses--;
} while (aspect.nextIter && aspect.nPasses);
if (GD_flags(g) & NEW_RANK)
removeFill (g);
dot_sameports(g);
dot_splines(g);
if (mapbool(agget(g, "compound")))
dot_compoundEdges(g);
}
void common_init_node(node_t * n)
{
char *str;
int html = 0;
ND_width(n) =
late_double(n, N_width, DEFAULT_NODEWIDTH, MIN_NODEWIDTH);
ND_height(n) =
late_double(n, N_height, DEFAULT_NODEHEIGHT, MIN_NODEHEIGHT);
if (N_label == NULL)
str = NODENAME_ESC;
else {
str = agxget(n, N_label->index);
html = aghtmlstr(str);
}
if (html)
str = strdup(str);
else
str = strdup_and_subst_node(str, n);
ND_label(n) = make_label(html, str,
late_double(n, N_fontsize, DEFAULT_FONTSIZE,
MIN_FONTSIZE), late_nnstring(n,
N_fontname,
DEFAULT_FONTNAME),
late_nnstring(n, N_fontcolor, DEFAULT_COLOR),
n->graph);
#ifdef ENABLE_HTML //maks
if (html) {
if (make_html_label(ND_label(n), n) == 1)
agerr(AGPREV, "in label of node %s\n", n->name);
}
#endif
ND_shape(n) =
bind_shape(late_nnstring(n, N_shape, DEFAULT_NODESHAPE), n);
ND_showboxes(n) = late_int(n, N_showboxes, 0, 0);
ND_shape(n)->fns->initfn(n);
}
/* fdp_initParams:
* Initialize parameters based on root graph attributes.
* Should K be a function of nnodes?
*/
void
fdp_initParams (graph_t* g)
{
if (fdp_args.numIters == -1)
numIters = late_int (g, agfindattr (g,"maxiter"),dflt_numIters,0);
else
numIters = fdp_args.numIters;
if (fdp_args.K == -1.0)
T_K = late_double (g, agfindattr (g,"K"),dflt_K,0.0);
else
T_K = fdp_args.K;
if (fdp_args.T0 == -1.0) {
T0 = late_double (g, agfindattr (g,"T0"),-1.0,0.0);
}
else
T0 = fdp_args.T0;
if (fdp_args.smode == seed_unset) {
if (fdp_setSeed(&smode,agget (g,"start"))) {
smode = dflt_smode;
}
}
else
smode = fdp_args.smode;
pass1 = (T_unscaled*numIters)/100;
K2 = T_K*T_K;
if (T_useGrid) {
if (Cell <= 0.0) Cell = 3*T_K;
Cell2 = Cell * Cell;
}
if (Verbose) {
fprintf (stderr, "Params: K %f T0 %f Tfact %f numIters %d unscaled %d\n",
T_K, T0, T_Tfact, numIters, T_unscaled);
}
}
/*
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);
}
void init_ugraph(graph_t *g)
{
char *p;
double xf;
static char *rankname[] = {"local","global","none",NULL};
static int rankcode[] = {LOCAL, GLOBAL, NOCLUST, LOCAL};
double X,Y,Z,x,y;
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_drawing(g)->quantum = late_double(g,agfindattr(g,"quantum"),0.0,0.0);
GD_drawing(g)->font_scale_adj = 1.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.
*/
if (UseRankdir)
GD_left_to_right(g) = ((p = agget(g,"rankdir")) && streq(p,"LR"));
else
GD_left_to_right(g) = FALSE;
do_graph_label(g);
xf = late_double(g,agfindattr(g,"nodesep"),DEFAULT_NODESEP,MIN_NODESEP);
GD_nodesep(g) = POINTS(xf);
p = late_string(g,agfindattr(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,agfindattr(g,"showboxes"),0,0);
Epsilon = .0001 * agnnodes(g);
getdoubles2pt(g,"size",&(GD_drawing(g)->size));
getdoubles2pt(g,"page",&(GD_drawing(g)->page));
getdouble(g,"epsilon",&Epsilon);
getdouble(g,"nodesep",&Nodesep);
getdouble(g,"nodefactor",&Nodefactor);
X = Y = Z = x = y = 0.0;
if ((p = agget(g,"viewport")))
sscanf(p,"%lf,%lf,%lf,%lf,%lf",&X,&Y,&Z,&x,&y);
GD_drawing(g)->viewport.size.x = ROUND(X); /* viewport size in dev units - pixels */
GD_drawing(g)->viewport.size.y = ROUND(Y);
GD_drawing(g)->viewport.zoom = Z; /* scaling factor */
GD_drawing(g)->viewport.focus.x = x; /* graph coord of focus - points */
GD_drawing(g)->viewport.focus.y = y;
GD_drawing(g)->centered = mapbool(agget(g,"center"));
if ((p = agget(g,"rotate"))) GD_drawing(g)->landscape = (atoi(p) == 90);
else { /* today we learned the importance of backward compatibilty */
if ((p = agget(g,"orientation")))
GD_drawing(g)->landscape = ((p[0] == 'l') || (p[0] == 'L'));
}
p = agget(g,"clusterrank");
CL_type = maptoken(p,rankname,rankcode);
p = agget(g,"concentrate");
Concentrate = mapbool(p);
Nodesep = 1.0;
Nodefactor = 1.0;
Initial_dist = MYHUGE;
}
void init_ugraph(graph_t* g)
{
char *p;
int i;
double xf;
static char *rankname[] = {"local","global","none",NULL};
static int rankcode[] = {LOCAL, GLOBAL, NOCLUST, LOCAL};
g->u.drawing = 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=(char *)realloc(buf,strlen("GDFONTPATH=")+strlen(p)+1);
strcpy(buf,"GDFONTPATH=");
strcat(buf,p);
putenv(buf);
#endif
}
g->u.drawing->quantum = late_float(g,agfindattr(g,"quantum"),0.0,0.0);
g->u.drawing->font_scale_adj = 1.0;
g->u.left_to_right = ((p = agget(g,"rankdir")) && streq(p,"LR"));
do_graph_label(g);
xf = late_float(g,agfindattr(g,"nodesep"),DEFAULT_NODESEP,MIN_NODESEP);
g->u.nodesep = POINTS(xf);
p = late_string(g,agfindattr(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")) g->u.exact_ranksep = TRUE;
}
else xf = DEFAULT_RANKSEP;
g->u.ranksep = POINTS(xf);
g->u.showboxes = late_int(g,agfindattr(g,"showboxes"),0,0);
Epsilon = .0001 * agnnodes(g);
getfloats2pt(g,"size",&(g->u.drawing->size));
getfloats2pt(g,"page",&(g->u.drawing->page));
getfloat(g,"epsilon",&Epsilon);
getfloat(g,"nodesep",&Nodesep);
getfloat(g,"nodefactor",&Nodefactor);
g->u.drawing->centered = mapbool(agget(g,"center"));
if ((p = agget(g,"rotate"))) g->u.drawing->landscape = (atoi(p) == 90);
else { /* today we learned the importance of backward compatibilty */
if ((p = agget(g,"orientation")))
g->u.drawing->landscape = ((p[0] == 'l') || (p[0] == 'L'));
}
p = agget(g,"clusterrank");
CL_type = maptoken(p,rankname,rankcode);
p = agget(g,"concentrate");
Concentrate = mapbool(p);
Nodesep = 1.0;
Nodefactor = 1.0;
Initial_dist = MYHUGE;
}
/* finalCC:
* Set graph bounding box given list of connected
* components, each with its bounding box set.
* If c_cnt > 1, then pts != NULL and gives translations for components.
* Add margin about whole graph unless isRoot is true.
* Reposition nodes based on final position of
* node's connected component.
* Also, entire layout is translated to origin.
*/
static void
finalCC(graph_t * g, int c_cnt, graph_t ** cc, point * pts, graph_t * rg,
layout_info* infop)
{
attrsym_t * G_width = infop->G_width;
attrsym_t * G_height = infop->G_height;
graph_t *cg;
box b, bb;
boxf bbf;
point pt;
int margin;
graph_t **cp = cc;
point *pp = pts;
int isRoot = (rg == infop->rootg);
int isEmpty = 0;
/* compute graph bounding box in points */
if (c_cnt) {
cg = *cp++;
BF2B(GD_bb(cg), bb);
if (c_cnt > 1) {
pt = *pp++;
bb.LL.x += pt.x;
bb.LL.y += pt.y;
bb.UR.x += pt.x;
bb.UR.y += pt.y;
while ((cg = *cp++)) {
BF2B(GD_bb(cg), b);
pt = *pp++;
b.LL.x += pt.x;
b.LL.y += pt.y;
b.UR.x += pt.x;
b.UR.y += pt.y;
bb.LL.x = MIN(bb.LL.x, b.LL.x);
bb.LL.y = MIN(bb.LL.y, b.LL.y);
bb.UR.x = MAX(bb.UR.x, b.UR.x);
bb.UR.y = MAX(bb.UR.y, b.UR.y);
}
}
} else { /* empty graph */
bb.LL.x = 0;
bb.LL.y = 0;
bb.UR.x = late_int(rg, G_width, POINTS(DEFAULT_NODEWIDTH), 3);
bb.UR.y = late_int(rg, G_height, POINTS(DEFAULT_NODEHEIGHT), 3);
isEmpty = 1;
}
if (GD_label(rg)) {
point p;
int d;
isEmpty = 0;
PF2P(GD_label(rg)->dimen, p);
d = p.x - (bb.UR.x - bb.LL.x);
if (d > 0) { /* height of label added below */
d /= 2;
bb.LL.x -= d;
bb.UR.x += d;
}
}
if (isRoot || isEmpty)
margin = 0;
else
margin = late_int (g, G_margin, CL_OFFSET, 0);
pt.x = -bb.LL.x + margin;
pt.y = -bb.LL.y + margin + GD_border(rg)[BOTTOM_IX].y;
bb.LL.x = 0;
bb.LL.y = 0;
bb.UR.x += pt.x + margin;
bb.UR.y += pt.y + margin + GD_border(rg)[TOP_IX].y;
/* translate nodes */
if (c_cnt) {
cp = cc;
pp = pts;
while ((cg = *cp++)) {
point p;
node_t *n;
pointf del;
if (pp) {
p = *pp++;
p.x += pt.x;
p.y += pt.y;
} else {
p = pt;
}
del.x = PS2INCH(p.x);
del.y = PS2INCH(p.y);
for (n = agfstnode(cg); n; n = agnxtnode(cg, n)) {
ND_pos(n)[0] += del.x;
ND_pos(n)[1] += del.y;
}
}
}
bbf.LL.x = PS2INCH(bb.LL.x);
bbf.LL.y = PS2INCH(bb.LL.y);
bbf.UR.x = PS2INCH(bb.UR.x);
bbf.UR.y = PS2INCH(bb.UR.y);
BB(g) = bbf;
}
