static void
initSubg (Agraph_t* sg, Agraph_t* g)
{
agbindrec(sg, "Agraphinfo_t", sizeof(Agraphinfo_t), TRUE);
GD_drawing(sg) = NEW(layout_t);
GD_drawing(sg)->quantum = GD_drawing(g)->quantum;
GD_drawing(sg)->dpi = GD_drawing(g)->dpi;
GD_gvc(sg) = GD_gvc (g);
GD_charset(sg) = GD_charset (g);
GD_rankdir2(sg) = GD_rankdir2 (g);
GD_nodesep(sg) = GD_nodesep(g);
GD_ranksep(sg) = GD_ranksep(g);
GD_fontnames(sg) = GD_fontnames(g);
}
int initHTMLlexer(char *src, agxbuf * xb, htmlenv_t *env)
{
#ifdef HAVE_EXPAT
state.xb = xb;
agxbinit (&state.lb, SMALLBUF, NULL);
state.ptr = src;
state.mode = 0;
state.warn = 0;
state.error = 0;
state.currtoklen = 0;
state.prevtoklen = 0;
state.inCell = 1;
state.parser = XML_ParserCreate(charsetToStr(GD_charset(env->g)));
XML_SetUserData(state.parser, GD_gvc(env->g));
XML_SetElementHandler(state.parser,
(XML_StartElementHandler) startElement,
endElement);
XML_SetCharacterDataHandler(state.parser, characterData);
return 0;
#else
static int first;
if (!first) {
agerr(AGWARN,
"Not built with libexpat. Table formatting is not available.\n");
first++;
}
return 1;
#endif
}
/* compiles <str> into a label <lp> and returns its bounding box size. */
static pointf label_size(char *str, textlabel_t * lp, graph_t * g)
{
char c, *p, *line, *lineptr;
unsigned char byte = 0x00;
int charset = GD_charset(g);
if (*str == '\0')
return lp->dimen;
line = lineptr = NULL;
p = str;
line = lineptr = N_GNEW(strlen(p) + 1, char);
*line = 0;
while ((c = *p++)) {
byte = (unsigned int) c;
/* wingraphviz allows a combination of ascii and big-5. The latter
* is a two-byte encoding, with the first byte in 0xA1-0xFE, and
* the second in 0x40-0x7e or 0xa1-0xfe. We assume that the input
* is well-formed, but check that we don't go past the ending '\0'.
*/
if ((charset == CHAR_BIG5) && 0xA1 <= byte && byte <= 0xFE) {
*lineptr++ = c;
c = *p++;
*lineptr++ = c;
if (!c) /* NB. Protect against unexpected string end here */
break;
} else {
if (c == '\\') {
switch (*p) {
case 'n':
case 'l':
case 'r':
*lineptr++ = '\0';
storeline(lp, line, *p, g);
line = lineptr;
break;
default:
*lineptr++ = *p;
}
if (*p)
p++;
/* tcldot can enter real linend characters */
} else if (c == '\n') {
*lineptr++ = '\0';
storeline(lp, line, 'n', g);
line = lineptr;
} else {
*lineptr++ = c;
}
}
}
if (line != lineptr) {
*lineptr++ = '\0';
storeline(lp, line, 'n', g);
}
return lp->dimen;
}
static void psgen_begin_graph(GVJ_t * job)
{
obj_state_t *obj = job->obj;
setupLatin1 = FALSE;
if (job->common->viewNum == 0) {
gvprintf(job, "%%%%Title: %s\n", agnameof(obj->u.g));
if (job->render.id != FORMAT_EPS)
gvputs(job, "%%Pages: (atend)\n");
else
gvputs(job, "%%Pages: 1\n");
if (job->common->show_boxes == NULL) {
if (job->render.id != FORMAT_EPS)
gvputs(job, "%%BoundingBox: (atend)\n");
else
gvprintf(job, "%%%%BoundingBox: %d %d %d %d\n",
job->pageBoundingBox.LL.x, job->pageBoundingBox.LL.y,
job->pageBoundingBox.UR.x, job->pageBoundingBox.UR.y);
}
gvputs(job, "%%EndComments\nsave\n");
/* include shape library */
cat_libfile(job, job->common->lib, ps_txt);
/* include epsf */
epsf_define(job);
if (job->common->show_boxes) {
const char* args[2];
args[0] = job->common->show_boxes[0];
args[1] = NULL;
cat_libfile(job, NULL, args);
}
}
isLatin1 = (GD_charset(obj->u.g) == CHAR_LATIN1);
/* We always setup Latin1. The charset info is always output,
* and installing it is cheap. With it installed, we can then
* rely on ps_string to convert UTF-8 characters whose encoding
* is in the range of Latin-1 into the Latin-1 equivalent and
* get the expected PostScript output.
*/
if (!setupLatin1) {
gvputs(job, "setupLatin1\n"); /* as defined in ps header */
setupLatin1 = TRUE;
}
/* Set base URL for relative links (for Distiller >= 3.0) */
if (obj->url)
gvprintf(job, "[ {Catalog} << /URI << /Base (%s) >> >>\n"
"/PUT pdfmark\n", obj->url);
}
static void json_end_graph(GVJ_t *job)
{
graph_t *g = job->obj->u.g;
state_t sp;
Agiodisc_t* io_save;
static Agiodisc_t io;
if (io.afread == NULL) {
io.afread = AgIoDisc.afread;
io.putstr = (putstrfn)gvputs;
io.flush = (flushfn)gvflush;
}
io_save = g->clos->disc.io;
g->clos->disc.io = &io;
set_attrwf(g, TRUE, FALSE);
sp.Level = 0;
sp.isLatin = (GD_charset(g) == CHAR_LATIN1);
sp.doXDot = ((job->render.id == FORMAT_JSON) || (job->render.id == FORMAT_XDOT_JSON));
sp.Attrs_not_written_flag = 0;
write_graph(g, job, TRUE, &sp);
/* agwrite(g, (FILE*)job); */
}
/* make_label:
* Assume str is freshly allocated for this instance, so it
* can be freed in free_label.
*/
textlabel_t *make_label(int html, char *str, double fontsize,
char *fontname, char *fontcolor, graph_t * g)
{
textlabel_t *rv = NEW(textlabel_t);
rv->text = str;
rv->fontname = fontname;
rv->fontcolor = fontcolor;
rv->fontsize = fontsize;
if (html)
rv->html = TRUE;
else if (GD_charset(g) == CHAR_LATIN1) {
#ifdef ENABLE_HTML //maks
char* lstr = latin1ToUTF8(str);
#else
char *lstr = str;
#endif
label_size(lstr, rv, g);
free(lstr);
}
else
label_size(str, rv, g);
return rv;
}
/* make_label:
* Assume str is freshly allocated for this instance, so it
* can be freed in free_label.
*/
textlabel_t *make_label(void *obj, char *str, int kind, double fontsize, char *fontname, char *fontcolor)
{
textlabel_t *rv = NEW(textlabel_t);
graph_t *g = NULL, *sg = NULL;
node_t *n = NULL;
edge_t *e = NULL;
char *s;
switch (agobjkind(obj)) {
case AGRAPH:
sg = (graph_t*)obj;
g = sg->root;
break;
case AGNODE:
n = (node_t*)obj;
g = agroot(agraphof(n));
break;
case AGEDGE:
e = (edge_t*)obj;
g = agroot(agraphof(aghead(e)));
break;
}
rv->fontname = fontname;
rv->fontcolor = fontcolor;
rv->fontsize = fontsize;
rv->charset = GD_charset(g);
if (kind & LT_RECD) {
rv->text = strdup(str);
if (kind & LT_HTML) {
rv->html = TRUE;
}
}
else if (kind == LT_HTML) {
rv->text = strdup(str);
rv->html = TRUE;
if (make_html_label(obj, rv)) {
switch (agobjkind(obj)) {
case AGRAPH:
agerr(AGPREV, "in label of graph %s\n",agnameof(sg));
break;
case AGNODE:
agerr(AGPREV, "in label of node %s\n", agnameof(n));
break;
case AGEDGE:
agerr(AGPREV, "in label of edge %s %s %s\n",
agnameof(agtail(e)), agisdirected(g)?"->":"--", agnameof(aghead(e)));
break;
}
}
}
else {
assert(kind == LT_NONE);
/* This call just processes the graph object based escape sequences. The formatting escape
* sequences (\n, \l, \r) are processed in make_simple_label. That call also replaces \\ with \.
*/
rv->text = strdup_and_subst_obj0(str, obj, 0);
switch (rv->charset) {
case CHAR_LATIN1:
s = latin1ToUTF8(rv->text);
break;
default: /* UTF8 */
s = htmlEntityUTF8(rv->text, g);
break;
}
free(rv->text);
rv->text = s;
make_simple_label(GD_gvc(g), rv);
}
return rv;
}
/*
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);
}
/* make_html_label:
* Return non-zero if problem parsing HTML. In this case, use object name.
*/
int make_html_label(graph_t *g, textlabel_t * lp, void *obj)
{
int rv;
int wd2, ht2;
box box;
htmllabel_t *lbl;
htmlenv_t env;
env.obj = obj;
switch (agobjkind(obj)) {
case AGGRAPH:
env.g = ((Agraph_t *) obj)->root;
break;
case AGNODE:
env.g = ((Agnode_t *) obj)->graph;
break;
case AGEDGE:
env.g = ((Agedge_t *) obj)->head->graph;
break;
}
env.finfo.size = lp->fontsize;
env.finfo.name = lp->fontname;
env.finfo.color = lp->fontcolor;
lbl = parseHTML(lp->text, &rv, GD_charset(env.g));
if (!lbl) {
/* Parse of label failed; revert to simple text label */
agxbuf xb;
unsigned char buf[SMALLBUF];
agxbinit(&xb, SMALLBUF, buf);
lp->html = FALSE;
lp->text = strdup(nameOf(obj, &xb));
size_label(env.g, lp);
agxbfree(&xb);
return rv;
}
if (lbl->kind == HTML_TBL) {
lbl->u.tbl->data.pencolor = getPenColor(obj);
rv |= size_html_tbl(g, lbl->u.tbl, NULL, &env);
wd2 = (lbl->u.tbl->data.box.UR.x + 1) / 2;
ht2 = (lbl->u.tbl->data.box.UR.y + 1) / 2;
box = boxof(-wd2, -ht2, wd2, ht2);
pos_html_tbl(lbl->u.tbl, box, BOTTOM | RIGHT | TOP | LEFT);
lp->dimen.x = box.UR.x - box.LL.x;
lp->dimen.y = box.UR.y - box.LL.y;
} else {
rv |= size_html_txt(g, lbl->u.txt, &env);
wd2 = (lbl->u.txt->box.UR.x + 1) / 2;
ht2 = (lbl->u.txt->box.UR.y + 1) / 2;
box = boxof(-wd2, -ht2, wd2, ht2);
lbl->u.txt->box = box;
lp->dimen.x = box.UR.x - box.LL.x;
lp->dimen.y = box.UR.y - box.LL.y;
}
lp->u.html = lbl;
/* If the label is a table, replace label text because this may
* be used for the title and alt fields in image maps.
*/
if (lbl->kind == HTML_TBL) {
free (lp->text);
lp->text = strdup ("<TABLE>");
}
return rv;
}
/* make_html_label:
* Return non-zero if problem parsing HTML. In this case, use object name.
*/
int make_html_label(void *obj, textlabel_t * lp)
{
int rv;
double wd2, ht2;
boxf box;
graph_t *g;
htmllabel_t *lbl;
htmlenv_t env;
char *s;
env.obj = obj;
switch (agobjkind(obj)) {
#ifdef WITH_CGRAPH
case AGRAPH:
#else
case AGGRAPH:
#endif
env.g = ((Agraph_t *) obj)->root;
break;
case AGNODE:
env.g = agraphof(((Agnode_t *) obj));
break;
case AGEDGE:
env.g = agraphof(aghead (((Agedge_t *) obj)));
break;
}
g = env.g->root;
env.finfo.size = lp->fontsize;
env.finfo.name = lp->fontname;
env.finfo.color = lp->fontcolor;
lbl = parseHTML(lp->text, &rv, GD_charset(env.g));
if (!lbl) {
/* Parse of label failed; revert to simple text label */
agxbuf xb;
unsigned char buf[SMALLBUF];
agxbinit(&xb, SMALLBUF, buf);
lp->html = FALSE;
lp->text = strdup(nameOf(obj, &xb));
switch (lp->charset) {
case CHAR_LATIN1:
s = latin1ToUTF8(lp->text);
break;
default: /* UTF8 */
s = htmlEntityUTF8(lp->text, env.g);
break;
}
free(lp->text);
lp->text = s;
make_simple_label(g, lp);
agxbfree(&xb);
return rv;
}
if (lbl->kind == HTML_TBL) {
if (! lbl->u.tbl->data.pencolor && getPenColor(obj))
lbl->u.tbl->data.pencolor = strdup(getPenColor(obj));
rv |= size_html_tbl(g, lbl->u.tbl, NULL, &env);
wd2 = (lbl->u.tbl->data.box.UR.x + 1) / 2;
ht2 = (lbl->u.tbl->data.box.UR.y + 1) / 2;
box = boxfof(-wd2, -ht2, wd2, ht2);
pos_html_tbl(lbl->u.tbl, box, BOTTOM | RIGHT | TOP | LEFT);
lp->dimen.x = box.UR.x - box.LL.x;
lp->dimen.y = box.UR.y - box.LL.y;
} else {
rv |= size_html_txt(g, lbl->u.txt, &env);
wd2 = (lbl->u.txt->box.UR.x + 1) / 2;
ht2 = (lbl->u.txt->box.UR.y + 1) / 2;
box = boxfof(-wd2, -ht2, wd2, ht2);
lbl->u.txt->box = box;
lp->dimen.x = box.UR.x - box.LL.x;
lp->dimen.y = box.UR.y - box.LL.y;
}
lp->u.html = lbl;
/* If the label is a table, replace label text because this may
* be used for the title and alt fields in image maps.
*/
if (lbl->kind == HTML_TBL) {
free (lp->text);
lp->text = strdup ("<TABLE>");
}
return rv;
}
