/*
    This software may only be used by you under license from AT&T Corp.
    ("AT&T").  A copy of AT&T's Source Code Agreement is available at
    AT&T's Internet website having the URL:
    <http://www.research.att.com/sw/tools/graphviz/license/source.html>
    If you received this software without first entering into a license
    with AT&T, you have an infringing copy of this software and cannot use
    it without violating AT&T's intellectual property rights.
*/
#pragma prototyped

/*
 *  graphics code generator
 */

#include	"render.h"
#include	"xbuf.h"
#include	"utils.h"


int			Obj;
static int			N_pages = 1;	/* w.r.t. unrotated coords */
static int			Page;			/* w.r.t. unrotated coords */
static int			Layer,Nlayers;
static char			**LayerID;
static point		First,Major,Minor;
static point		Pages;
static box			PB;		/* drawable region in device coords */
static pointf		GP;		/* graph page size, in graph coords */
static box			CB;		/* current page box, in graph coords */
static point		PFC;	/* device page box for centering */
static double	    Deffontsize;
static char			*Deffontname;
static char			Layerdelims[] = ":\t ";
static attrsym_t*   G_peripheries;


static int write_edge_test(Agraph_t *g, Agedge_t *e) {
	Agraph_t	*subg;
	int			c;

	for(c = 1; c <= GD_n_cluster(g); c++) {
		subg = GD_clust(g)[c];
		if(agcontains(subg, e)) return FALSE;
	}
	return TRUE;
}


static int write_node_test(Agraph_t *g, Agnode_t *n) {
	Agraph_t	*subg;
	int			c;

	for(c = 1; c <= GD_n_cluster(g); c++) {
		subg = GD_clust(g)[c];
		if(agcontains(subg, n)) return FALSE;
	}
	return TRUE;
}


void emit_reset(Agraph_t* g)
{
	Agnode_t	*n;

	N_pages = 1;
	Page = 0;
	Layer = Nlayers = 0;
	LayerID = (char **) 0;
	First.x = First.y = 0;
	Major.x = Major.y = 0;
	Minor.x = Minor.y = 0;
	Pages.x = Pages.y = 0;
	PB.LL.x = PB.LL.y = PB.UR.x = PB.UR.y = 0;
	GP.x = GP.y = 0;
	CB.LL.x = CB.LL.y = CB.UR.x = CB.UR.y = 0;
	PFC.x = PFC.y = 0;
	Deffontsize = 0;
	Deffontname = (char *) 0;

	for (n = agfstnode(g); n; n = agnxtnode(g,n)) {
		ND_state(n) = 0;
	}

	if(CodeGen) CodeGen->reset();
}

void emit_graph(graph_t* g, int flags)
{
	point	curpage;
	graph_t	*subg;
	node_t	*n;
	edge_t	*e;
	int	c;
	char	*str;

	G_peripheries =  agfindattr(g,"peripheries");
	emit_header(g);
	if (flags & EMIT_COLORS) {
		CodeGen->set_fillcolor(DEFAULT_FILL);
		if (((str = agget(g,"bgcolor")) != 0) && str[0])
			CodeGen->set_fillcolor(str);
		if (((str = agget(g,"fontcolor")) != 0) && str[0])
			CodeGen->set_pencolor(str);
		for (c = 1; c <= GD_n_cluster(g); c++) { 
	                subg = GD_clust(g)[c];
			if (((str = agget(subg,"color")) != 0) && str[0])
				CodeGen->set_pencolor(str);
			if (((str = agget(subg,"fillcolor")) != 0) && str[0])
				CodeGen->set_fillcolor(str);
			if (((str = agget(subg,"fontcolor")) != 0) && str[0])
				CodeGen->set_pencolor(str);
		}
		for (n = agfstnode(g); n; n = agnxtnode(g,n)) {
			if (((str = agget(n,"color")) != 0) && str[0])
				CodeGen->set_pencolor(str);
			if (((str = agget(n,"fillcolor")) != 0) && str[0])
				CodeGen->set_fillcolor(str);
			if (((str = agget(n,"fontcolor")) != 0) && str[0])
				CodeGen->set_pencolor(str);
			for (e = agfstout(g,n); e; e = agnxtout(g,e)) {
				if (((str = agget(e,"color")) != 0) && str[0])
					CodeGen->set_pencolor(str);
				if (((str = agget(e,"fontcolor")) != 0) && str[0])
					CodeGen->set_pencolor(str);
			}
		}
	}
	Layer = 1;
	do {
		if (Nlayers > 0) emit_layer(Layer);
		for (curpage = First; validpage(curpage); curpage = pageincr(curpage)) {
			Obj = NONE;
			setup_page(g,curpage);
			if (GD_label(g)) emit_label(GD_label(g),g);
			Obj = CLST;
			/* when drawing, lay clusters down before nodes and edges */
			if (!(flags & EMIT_CLUSTERS_LAST)) {
				emit_clusters(g,flags);
			}
			if (flags & EMIT_SORTED) {
				/* output all nodes, then all edges */
				Obj = NODE;
				CodeGen->begin_nodes();
				for (n = agfstnode(g); n; n = agnxtnode(g,n)) {
					emit_node(n);
				}
				CodeGen->end_nodes();
				Obj = EDGE;
				CodeGen->begin_edges();
				for (n = agfstnode(g); n; n = agnxtnode(g,n)) {
					for (e = agfstout(g,n); e; e = agnxtout(g,e)) {
						emit_edge(e);
					}
				}
				CodeGen->end_edges();
			}
			else if (flags & EMIT_EDGE_SORTED) {
				/* output all edges, then all nodes */
				Obj = EDGE;
				CodeGen->begin_edges();
				for (n = agfstnode(g); n; n = agnxtnode(g,n)) {
					for (e = agfstout(g,n); e; e = agnxtout(g,e)) {
						emit_edge(e);
					}
				}
				CodeGen->end_edges();
				Obj = NODE;
				CodeGen->begin_nodes();
				for (n = agfstnode(g); n; n = agnxtnode(g,n)) {
					emit_node(n);
				}
				CodeGen->end_nodes();
			}
			else if(flags & EMIT_PREORDER) {
				Obj = NODE;
				CodeGen->begin_nodes();
				for(n = agfstnode(g); n; n = agnxtnode(g, n)) {
					if(write_node_test(g, n))
						emit_node(n);
				}
				CodeGen->end_nodes();
				Obj = EDGE;
				CodeGen->begin_edges();

				for(n = agfstnode(g); n; n = agnxtnode(g, n)) {
					for(e = agfstout(g, n); e; e = agnxtout(g, e)) {
						if(write_edge_test(g, e))
							emit_edge(e);
					}
				}
				CodeGen->end_edges();
			}
			else {
				/* output in breadth first graph walk order */
				for (n = agfstnode(g); n; n = agnxtnode(g,n)) {
					Obj = NODE;
					emit_node(n);
					for (e = agfstout(g,n); e; e = agnxtout(g,e)) {
						Obj = NODE;
						emit_node(e->head);
						Obj = EDGE;
						emit_edge(e);
					}
				}    
			}
			/* when mapping, detect events on clusters after nodes and edges */
			if (flags & EMIT_CLUSTERS_LAST) {
				emit_clusters(g,flags);
			}
			Obj = NONE;
			CodeGen->end_page();
		}
		Layer++;
	} while (Layer <= Nlayers);
	emit_trailer();
}

void emit_eof(void)
{
	if (Page > 0) CodeGen->end_job();
}

void emit_clusters(graph_t* g, int flags)
{
	int			i,c,filled;
	graph_t		*subg;
	point		A[4];
	char		*str,**style;
	node_t		*n;
	edge_t		*e;


	for (c = 1; c <= GD_n_cluster(g); c++) {
		subg = GD_clust(g)[c];
		if (clust_in_layer(subg) == FALSE) continue;
		/* when mapping, detect events on clusters after sub_clusters */
		if (flags & EMIT_CLUSTERS_LAST) {
			emit_clusters(subg,flags);
		}
		Obj = CLST;
		CodeGen->begin_cluster(subg);
		CodeGen->begin_context();
		filled = FALSE;
		if (((str = agget(subg,"style")) != 0) && str[0]) {
			CodeGen->set_style(style = parse_style(str));
			for (i = 0; style[i]; i++) 
				if (strcmp(style[i],"filled")==0) {filled = TRUE; break;}
		}
		if (((str = agget(subg,"pencolor")) != 0) && str[0])
			CodeGen->set_pencolor(str);
		else if (((str = agget(subg,"color")) != 0) && str[0])
			CodeGen->set_pencolor(str);
		/* bgcolor is supported for backward compatability */
		else if (((str = agget(subg,"bgcolor")) != 0) && str[0])
			CodeGen->set_pencolor(str);

		str = 0;
		if (((str = agget(subg,"fillcolor")) != 0) && str[0])
			CodeGen->set_fillcolor(str);
		else if (((str = agget(subg,"color")) != 0) && str[0])
			CodeGen->set_fillcolor(str);
		/* bgcolor is supported for backward compatability */
		else if (((str = agget(subg,"bgcolor")) != 0) && str[0]) {
			filled = TRUE;
			CodeGen->set_fillcolor(str);
		}
		A[0] = GD_bb(subg).LL;
		A[2] = GD_bb(subg).UR;
		A[1].x = A[2].x; A[1].y = A[0].y;
		A[3].x = A[0].x; A[3].y = A[2].y;
		if (late_int(subg,G_peripheries,1,0)) {
			CodeGen->polygon(A,4,filled);
		}
		else if (filled) {
			CodeGen->set_pencolor(str);
			CodeGen->polygon(A,4,filled);
        }
		if (GD_label(subg)) emit_label(GD_label(subg),subg);

		if(flags & EMIT_PREORDER) {
			for(n = agfstnode(subg); n; n = agnxtnode(subg, n)) {
				Obj = NODE;
				emit_node(n);
				for(e = agfstout(subg, n); e; e = agnxtout(subg, e)) {
					Obj = EDGE;
					emit_edge(e);
				}
			}
			Obj = NONE;
		}

		CodeGen->end_context();
		CodeGen->end_cluster();
		/* when drawing, lay down clusters before sub_clusters */
		if (!(flags & EMIT_CLUSTERS_LAST)) {
			emit_clusters(subg,flags);
		}
	}
}

void emit_node(node_t* n)
{
	if (ND_shape(n) == NULL) return;
	if (node_in_layer(n->graph,n) && node_in_CB(n) && (ND_state(n) != Page)) {
		ND_shape(n)->codefn(n);
		ND_state(n) = Page;
	}
}

void emit_edge(edge_t* e)
{
	int		i;
	char	*color,*style;
	char	**styles = 0;
	char	**sp;
	bezier	bz;
	boolean	saved = FALSE;
	double	scale;
	double theta;
	char	*p;

	if ((edge_in_CB(e) == FALSE) || (edge_in_layer(e->head->graph,e) == FALSE))
		return;

	CodeGen->begin_edge(e);
	style = late_string(e,E_style,"");
		/* We shortcircuit drawing an invisible edge because the arrowhead
         * code resets the style to solid, and most of the code generators
		 * (except PostScript) won't honor a previous style of invis.
         */
	if (style[0]) {
      styles = parse_style(style);
      sp = styles;
	  while ((p = *sp++)) {
		if (streq(p, "invis")) {
			CodeGen->end_edge();
			return;
        }
      }
    }
	color = late_string(e,E_color,"");
	scale = late_double(e,E_arrowsz,1.0,0.0);
	if (color[0] || styles) {
		CodeGen->begin_context();
		if (styles) CodeGen->set_style(styles);
		if (color[0]) {
			CodeGen->set_pencolor(color);
			CodeGen->set_fillcolor(color);
		}
		saved = TRUE;
	}
	if (ED_spl(e)) {
		for (i = 0; i < ED_spl(e)->size; i++) {
			bz = ED_spl(e)->list[i];
			if (NOT(codegen_bezier_has_arrows())) {
				CodeGen->beziercurve(bz.list,bz.size,FALSE,FALSE);
				/* CodeGen->beziercurve(bz.list,bz.size,bz.sflag,bz.eflag); */
                /* vladimir: added sflag/eflag, arrowheads are made here */
				if (bz.sflag) {
					/* dds: open style has sp == list[0] */
					if ((bz.sflag == ARR_OPEN) || (bz.sflag == ARR_HALFOPEN))
						theta = atan2pt(bz.list[1],bz.list[0]);
					else
						theta = atan2pt(bz.list[0],bz.sp);
					arrow_gen(bz.sp, DEGREES(theta), scale, bz.sflag);
				}
				if (bz.eflag) {
					/* dds: open style has ep == list[size-1] */
					if ((bz.eflag == ARR_OPEN) || (bz.eflag == ARR_HALFOPEN))
						theta = atan2pt(bz.list[bz.size-2],bz.list[bz.size-1]);
					else
						theta = atan2pt(bz.list[bz.size-1],bz.ep);
					arrow_gen(bz.ep, DEGREES(theta), scale, bz.eflag);
				}
			} else 
				CodeGen->beziercurve(bz.list,bz.size,bz.sflag,bz.eflag);
		}
	}
	if (ED_label(e)) {
		emit_label(ED_label(e),e->tail->graph);
		if (mapbool(late_string(e,E_decorate,"false")) && ED_spl(e))
			emit_attachment(ED_label(e),ED_spl(e));
	}
	if (ED_head_label(e)) emit_label(ED_head_label(e),e->tail->graph); /* vladimir */
	if (ED_tail_label(e)) emit_label(ED_tail_label(e),e->tail->graph); /* vladimir */

	if (saved) CodeGen->end_context();
	CodeGen->end_edge();
}

int node_in_CB(node_t* n)
{
	box	nb;

	if (N_pages == 1) return TRUE;
	nb.LL.x = ND_coord_i(n).x - ND_lw_i(n);
	nb.LL.y = ND_coord_i(n).y - ND_ht_i(n)/2;
	nb.UR.x = ND_coord_i(n).x + ND_rw_i(n);
	nb.UR.y = ND_coord_i(n).y + ND_ht_i(n)/2;
	return rect_overlap(CB,nb);
}

int node_in_layer(graph_t* g, node_t* n)
{
	char	*pn,*pe;
	edge_t	*e;

	if (Nlayers <= 0) return TRUE;
	pn = late_string(n,N_layer,"");
	if (selectedlayer(pn)) return TRUE;
	if (pn[0]) return FALSE;  /* Only check edges if pn = "" */
	if ((e = agfstedge(g,n)) == NULL) return TRUE;
	for (e = agfstedge(g,n); e; e = agnxtedge(g,e,n)) {
		pe = late_string(e,E_layer,"");
		if ((pe[0] == '\0') || selectedlayer(pe)) return TRUE;
	}
	return FALSE;
}

int edge_in_layer(graph_t* g, edge_t* e)
{
	char	*pe,*pn;
	int		cnt;

	if (Nlayers <= 0) return TRUE;
	pe = late_string(e,E_layer,"");
	if (selectedlayer(pe)) return TRUE;
	if (pe[0]) return FALSE;
	for (cnt = 0; cnt < 2; cnt++) {
		pn = late_string(cnt < 1? e->tail:e->head,N_layer,"");
		if ((pn[0] == '\0') || selectedlayer(pn)) return TRUE;
	}
	return FALSE;
}

int clust_in_layer(graph_t* subg)
{
	char		*pg;
	node_t		*n;

	if (Nlayers <= 0) return TRUE;
	pg = late_string(subg,agfindattr(subg,"layer"),"");
	if (selectedlayer(pg)) return TRUE;
	if (pg[0]) return FALSE;
	for (n = agfstnode(subg); n; n = agnxtnode(subg,n))
		if (node_in_layer(subg,n)) return TRUE;
	return FALSE;
}

int edge_in_CB(edge_t* e)
{
	int		i,j,np;
	bezier	bz;
	point	*p,pp,sz;
	box		b;
	textlabel_t	*lp;

	if (N_pages == 1) return TRUE;
	if (ED_spl(e) == NULL) return FALSE;
	for (i = 0; i < ED_spl(e)->size; i++) {
		bz = ED_spl(e)->list[i];
		np = bz.size;
		p = bz.list;
		pp = p[0];
		for (j = 0; j < np; j++) {
			if (rect_overlap(CB,mkbox(pp,p[j]))) return TRUE;
			pp = p[j];
		}
	}
	if ((lp = ED_label(e)) == NULL) return FALSE;
	sz = cvt2pt(lp->dimen);
	b.LL.x = lp->p.x - sz.x / 2; b.UR.x = lp->p.x + sz.x / 2;
	b.LL.y = lp->p.y - sz.y / 2; b.UR.y = lp->p.y + sz.y / 2;
	return rect_overlap(CB,b);
}

void emit_attachment(textlabel_t* lp, splines* spl)
{
	point	sz,A[3];
	char	*s;

	for (s = lp->text; *s; s++) if (isspace(*s) == FALSE) break;
	if (*s == 0) return;

	sz = cvt2pt(lp->dimen);
	A[0] = pointof(lp->p.x + sz.x/2,lp->p.y - sz.y/2);
	A[1] = pointof(A[0].x - sz.x, A[0].y);
	A[2] = dotneato_closest(spl,lp->p);
	CodeGen->polyline(A,3);
}

void emit_header(graph_t* g)
{
	char	*user;

	setup_graph(g);
	if (Page == 0) {
		user = username();
		CodeGen->begin_job(Output_file,g,Lib,user,Info,Pages);
	}
	CodeGen->begin_graph(g,PB,PFC);
}

void emit_trailer(void)
{
	CodeGen->end_graph();
}

point pagecode(char c)
{
	point		rv;
	rv.x = rv.y = 0;
	switch(c) {
		case 'T': First.y = Pages.y - 1; rv.y = -1; break;
		case 'B': rv.y = 1; break;
		case 'L': rv.x = 1; break;
		case 'R': First.x = Pages.x - 1; rv.x = -1; break;
	}
	return rv;
}

static void set_pagedir(graph_t* g)
{
	char	*str;

	Major.x = Major.y = Minor.x = Minor.y = 0;
	str = agget(g,"pagedir");
	if (str && str[0]) {
		Major = pagecode(str[0]);
		Minor = pagecode(str[1]);
	}
	if ((abs(Major.x + Minor.x) != 1) || (abs(Major.y + Minor.y) != 1)) {
		Major.x = 0; Major.y = 1; Minor.x = 1; Minor.y = 0;
		First.x = First.y = 0;
		if (str) agerr (AGWARN, "pagedir=%s ignored\n",str);
	}
}

int validpage(point page)
{
	return ((page.x >= 0) && (page.x < Pages.x) 
		&& (page.y >= 0) && (page.y < Pages.y));
}

int layerindex(char* tok)
{
	int		i;

	for (i = 1; i <= Nlayers; i++) 
		if (streq(tok,LayerID[i])) return i;
	return -1;
}

int is_natural_number(char* str)
{
	while (*str) if (NOT(isdigit(*str++))) return FALSE;
	return TRUE;
}

int layer_index(char* str, int all)
{
	int		i;

	if (streq(str,"all")) return all;
	if (is_natural_number(str)) return atoi(str);
	if (LayerID)
		for (i = 1; i <= Nlayers; i++)
			if (streq(str,LayerID[i])) return i;
	return -1;
}

int selectedlayer(char* spec)
{
	int		n0,n1;
	unsigned char	buf[SMALLBUF];
	char	*w0, *w1;
    xbuf    xb;
    int     rval = FALSE;

    xbinit (&xb, SMALLBUF, buf);
	xbput(&xb,spec);
	w1 = w0 = strtok(xbuse(&xb),Layerdelims);
	if (w0) w1 = strtok(NULL,Layerdelims);
	switch((w0 != NULL) + (w1 != NULL)) {
	case 0: 
      rval = FALSE;
      break;
	case 1: 
      n0 = layer_index(w0,Layer);
	  rval = (n0 == Layer);
      break;
	case 2: 
      n0 = layer_index(w0,0);  
      n1 = layer_index(w1,Nlayers);
	  if ((n0 < 0) || (n1 < 0)) rval = TRUE;
	  else if (n0 > n1) {
        int t = n0; 
        n0 = n1; 
        n1 = t;}
		rval = BETWEEN(n0,Layer,n1);
      break;
	}
    xbfree (&xb);
	return rval;
}

point
pageincr(point page)
{
	page = add_points(page,Minor);
	if (validpage(page) == FALSE) {
		if (Major.y) page.x = First.x;
		else page.y = First.y;
		page = add_points(page,Major);
	}
	return page;
}

static point exch_xy(point p)
{
	int		t;
	t = p.x; p.x = p.y; p.y = t;
	return p;
}

static pointf exch_xyf(pointf p)
{
	double		t;
	t = p.x; p.x = p.y; p.y = t;
	return p;
}

/* this isn't a pretty sight... */
void setup_graph(graph_t* g)
{
	double		xscale,yscale,scale;
	char		*p;
	point		PFCLM;	/* page for centering less margins */
	point		DS;		/* device drawable region for a page of the graph */

	assert((GD_bb(g).LL.x == 0) && (GD_bb(g).LL.y == 0));

	if (LayerID) free(LayerID);
	if ((p = agget(g,"layers")) != 0) Nlayers = parse_layers(p);
	else {LayerID = NULL; Nlayers = 0;}

	/* determine final drawing size and scale to apply. */
	/* N.B. magnification could be allowed someday in the next conditional */
	/* N.B. size given by user is not rotated by landscape mode */
	if ((GD_drawing(g)->size.x > 0)	/* was given by user... */
		&& ((GD_drawing(g)->size.x < GD_bb(g).UR.x) /* drawing is too big... */
			|| (GD_drawing(g)->size.y < GD_bb(g).UR.y))) {
		xscale = ((double)GD_drawing(g)->size.x) / GD_bb(g).UR.x;
		yscale = ((double)GD_drawing(g)->size.y) / GD_bb(g).UR.y;
		scale = MIN(xscale,yscale);
		GD_drawing(g)->scale = scale;
		GD_drawing(g)->size.x = scale * GD_bb(g).UR.x;
		GD_drawing(g)->size.y = scale * GD_bb(g).UR.y;
	}
	else {	/* go with "natural" size of layout */
		GD_drawing(g)->size = GD_bb(g).UR;
		scale = GD_drawing(g)->scale = 1.0;
	}

	/* determine pagination */
	PB.LL = GD_drawing(g)->margin;
	if ((GD_drawing(g)->page.x > 0) && (GD_drawing(g)->page.y > 0)) {
			/* page was set by user */
		point	tp;
		PFC = GD_drawing(g)->page;
		PFCLM.x = PFC.x - 2*PB.LL.x; PFCLM.y = PFC.y - 2*PB.LL.y;
		GP.x = PFCLM.x ; GP.y = PFCLM.y;	/* convert to double */
		if (GD_drawing(g)->landscape) GP = exch_xyf(GP);
		GP.x = GP.x / scale; GP.y = GP.y / scale;
			/* we don't want graph page to exceed its bounding box */
		GP.x = MIN(GP.x,GD_bb(g).UR.x); GP.y = MIN(GP.y,GD_bb(g).UR.y);
		Pages.x = (GP.x > 0) ? ceil( ((double)GD_bb(g).UR.x) / GP.x) : 1;
		Pages.y = (GP.y > 0) ? ceil( ((double)GD_bb(g).UR.y) / GP.y) : 1;
		N_pages = Pages.x * Pages.y;

			/* find the drawable size in device coords */
		tp = GD_drawing(g)->size;
		if (GD_drawing(g)->landscape) tp = exch_xy(tp);
		DS.x = MIN(tp.x,PFCLM.x);
		DS.y = MIN(tp.y,PFCLM.y);
	}
	else {
			/* page not set by user, assume default when centering,
				but allow infinite page for any other interpretation */
		GP.x = GD_bb(g).UR.x; GP.y = GD_bb(g).UR.y;
		PFC.x = DEFAULT_PAGEWD; PFC.y = DEFAULT_PAGEHT;
		PFCLM.x = PFC.x - 2*PB.LL.x; PFCLM.y = PFC.y - 2*PB.LL.y;
		DS = GD_drawing(g)->size;
		if (GD_drawing(g)->landscape) DS = exch_xy(DS);
		Pages.x = Pages.y = N_pages = 1;
	}

	set_pagedir(g);
	/* determine page box including centering */
	if (GD_drawing(g)->centered) {
		point	extra;
		if ((extra.x = PFCLM.x - DS.x) < 0) extra.x = 0;
		if ((extra.y = PFCLM.y - DS.y) < 0) extra.y = 0;
		PB.LL.x += extra.x / 2; PB.LL.y += extra.y / 2;
	}
	PB.UR = add_points(PB.LL,DS);
	Deffontname = late_nnstring(g->proto->n,N_fontname,DEFAULT_FONTNAME);
	Deffontsize = late_double(g->proto->n,N_fontsize,DEFAULT_FONTSIZE,MIN_FONTSIZE);
}

void emit_background(graph_t* g, point LL, point UR)
{
	char	*str;
	point	A[4];

	if (((str = agget(g,"bgcolor")) != 0) && str[0]) {
		A[0].x = A[1].x = LL.x - GD_drawing(g)->margin.x;
		A[2].x = A[3].x = UR.x + GD_drawing(g)->margin.x;
		A[1].y = A[2].y = UR.y + GD_drawing(g)->margin.y;
		A[3].y = A[0].y = LL.y - GD_drawing(g)->margin.y;
		CodeGen->set_fillcolor(str);
		CodeGen->set_pencolor(str);
		CodeGen->polygon(A,4,TRUE);	/* filled */
	}
}

/* even if this makes you cringe, at least it's short */
void setup_page(graph_t* g, point page)
{
	point		offset;
	int			theta;

	Page++;
	theta = (GD_drawing(g)->landscape ? 90 : 0);

	/* establish current box in graph coordinates */
	CB.LL.x = page.x  * GP.x;	CB.LL.y = page.y * GP.y;
	CB.UR.x = CB.LL.x + GP.x;	CB.UR.y = CB.LL.y + GP.y;

	/* establish offset to be applied, in graph coordinates */
	if (GD_drawing(g)->landscape == FALSE) offset = pointof(-CB.LL.x,-CB.LL.y);
	else { offset.x = (page.y + 1) * GP.y; offset.y = -page.x * GP.x; }
	CodeGen->begin_page(g,page,GD_drawing(g)->scale,theta,offset);
	emit_background(g, CB.LL, CB.UR);
	emit_defaults(g);
}

void emit_label(textlabel_t* lp, Agraph_t *g)
{
	int	i, linespacing, left_x, center_x, right_x, width_x;
	point	p;

	/* make sure that there is something to do */
	if (lp->nlines < 1) return;

	g = g->root;

	/* dimensions of box for label */
	width_x = ROUND(POINTS(lp->dimen.x));
	center_x = lp->p.x;
	left_x = center_x - width_x / 2;
	right_x = center_x + width_x / 2;

	/* set linespacing */
	linespacing = (int)(lp->fontsize * LINESPACING);

	/* position for first line */
	p.y = lp->p.y
		+ (linespacing * (lp->nlines -1) / 2)	/* cl of topline */
	       	- lp->fontsize / 3.0 ; /* cl to baseline */

	CodeGen->begin_context();
	CodeGen->set_pencolor(lp->fontcolor);
	CodeGen->set_font(lp->fontname,lp->fontsize*GD_drawing(g)->font_scale_adj);

	for (i = 0; i < lp->nlines; i++) {
		switch(lp->line[i].just) {
			case 'l':
				p.x = left_x;
				break;
			case 'r':
				p.x = right_x;
				break;
			default:
			case 'n':
				p.x = center_x;
				break;
		}
		CodeGen->textline(p,&(lp->line[i]));

		/* position for next line */
		p.y -= linespacing;
	}

	CodeGen->end_context();
}

void emit_defaults(graph_t* g)
{
	CodeGen->set_pencolor(DEFAULT_COLOR);
	CodeGen->set_fillcolor(DEFAULT_COLOR);
	CodeGen->set_font(Deffontname,Deffontsize);
}

int parse_layers(char* p)
{
	int		ntok,c;
	char	*pcopy,*tok;

	ntok = strccnt(p,':')+1;
	pcopy = strdup(p);
	if (LayerID) free(LayerID);
	LayerID = N_NEW(ntok+2,char*);
	c = 1;
	for (tok = strtok(pcopy,Layerdelims); tok; tok = strtok(NULL,Layerdelims)) 
		LayerID[c++] = tok;
	return ntok;
}

void emit_layer(int n)
{
	char	buf[BUFSIZ],*fake[2];
	char	null = 0;

	if (LayerID) {
		/* create compatible char array structure for set_style call */
		sprintf(buf,"setlayer%c%d%c%d%c",null,n,null,Nlayers,null);
		fake[0] = buf;
		fake[1] = NULL;
		CodeGen->set_style(fake);
	}
}

static int style_delim(int c)
{
	switch (c) {
		case '(': case ')': case ',': case '\0': return TRUE;
		default : return FALSE;
	}
}

#define SID 1

static int
style_token(char** s, xbuf *xb)
{
    char* p = *s;
    int token;
    char  c;

	while (*p && (isspace(*p) || (*p ==','))) p++;
	switch (*p) {
	case '\0': token = 0; break;
	case '(': case ')': token = *p++; break;
	default: 
        token = SID;
        while (!style_delim(c = *p)) {
          xbputc(xb,c);
          p++;
        }
	}
    *s = p;
	return token;
}

#define FUNLIMIT 64
static unsigned char outbuf[SMALLBUF];
static xbuf ps_xb;

static void
cleanup()
{
  xbfree(&ps_xb);
}

char **
parse_style(char* s)
{
	static char*   parse[FUNLIMIT];
    static int     first = 1;
	int			   fun = 0;
	boolean		   in_parens = FALSE;
	unsigned char  buf[SMALLBUF];
    char*          p;
    int            c;
    xbuf           xb;

    if (first) {
      xbinit (&ps_xb, SMALLBUF, outbuf);
      atexit(cleanup);
      first = 0;
    }

    xbinit (&xb, SMALLBUF, buf);
	p = s;
	while ((c = style_token(&p,&xb)) != 0) {
		switch (c) {
		case '(':
			if (in_parens) {
				agerr(AGERR, "nesting not allowed in style: %s\n",s);
				parse[0] = (char*)0;
                xbfree (&xb);
				return parse;
			}
			in_parens = TRUE;
			break;

		case ')':
			if (in_parens == FALSE) {
				agerr(AGERR, "unmatched ')' in style: %s\n",s);
				parse[0] = (char*)0;
                xbfree (&xb);
				return parse;
			}
			in_parens = FALSE; 
			break;

		default:
			if (in_parens == FALSE) {
                if (fun == FUNLIMIT-1) {
                    agerr(AGWARN, "truncating style '%s'\n", s);
	                parse[fun] = (char*)0;
                    xbfree (&xb);
                    return parse;
                }
                xbputc(&ps_xb, '\0'); /* terminate previous */
				parse[fun++] = xbnext(&ps_xb);
			}
			xbput (&ps_xb, xbuse(&xb));
            xbputc(&ps_xb, '\0');
		}
	}

	if (in_parens) {
		agerr(AGERR, "unmatched '(' in style: %s\n",s);
		parse[0] = (char*)0;
        xbfree (&xb);
		return parse;
	}
	parse[fun] = (char*)0;
    xbfree (&xb);
    xbuse (&ps_xb);  /* adds final '\0' to buffer */
	return parse;
}

static struct cg_s {
        codegen_t   *cg;
        char        *name;
        int         id;
    }
    gens[] = {
        {&PS_CodeGen,"ps",POSTSCRIPT},
        {&PS_CodeGen,"ps2",PDF},
        {&HPGL_CodeGen,"hpgl",HPGL},
        {&HPGL_CodeGen,"pcl",PCL},
        {&MIF_CodeGen,"mif",MIF},
        {&PIC_CodeGen,"pic",PIC_format},
        {&GD_CodeGen,"gd",GD},
#ifdef HAVE_LIBZ
        {&GD_CodeGen,"gd2",GD2},
#endif
#ifdef WITH_GIF
        {&GD_CodeGen,"gif",GIF},
#endif
#ifdef HAVE_LIBJPEG
        {&GD_CodeGen,"jpg",JPEG},
        {&GD_CodeGen,"jpeg",JPEG},
#endif
#ifdef HAVE_LIBPNG
#ifdef HAVE_LIBZ
        {&GD_CodeGen,"png",PNG},
#endif
#endif
        {&GD_CodeGen,"wbmp",WBMP},
#ifdef HAVE_LIBXPM
        {&GD_CodeGen,"xbm",XBM},
#endif
        {&ISMAP_CodeGen,"ismap",ISMAP},
        {&IMAP_CodeGen,"imap",IMAP},
        {&CMAP_CodeGen,"cmap",CMAP},
#ifdef HAVE_LIBPNG
        {&VRML_CodeGen,"vrml",VRML},
#endif
        {&VTX_CodeGen,"vtx",VTX},
        {&MP_CodeGen,"mp",METAPOST},
        {&FIG_CodeGen,"fig",FIG},
        {&SVG_CodeGen,"svg",SVG},
#ifdef HAVE_LIBZ
        {&SVG_CodeGen,"svgz",SVGZ},
        {&DIA_CodeGen,"dia",DIA},
#endif
        {(codegen_t*)0,"dot",ATTRIBUTED_DOT},
        {(codegen_t*)0,"canon",CANONICAL_DOT},
        {(codegen_t*)0,"plain",PLAIN},
        {(codegen_t*)0,"plain-ext",PLAIN_EXT},
        {&XDot_CodeGen,"xdot",EXTENDED_DOT},
        {(codegen_t*)0,(char*)0,0}
    };

int lang_select(char* str, int warn)
{
    struct  cg_s *p;
    for (p = gens; p->name; p++) {
        if (strcasecmp(str,p->name) == 0) {
            CodeGen = p->cg;
            return p->id;
        }
    }
	if (warn) {
    	agerr(AGWARN, "language %s not recognized, use one of:\n",str);
    	for (p = gens; p->name; p++) agerr(AGPREV, " %s",p->name);
    	agerr(AGPREV, "\n");
	}
    return ATTRIBUTED_DOT;
}

FILE *
file_select(char* str)
{
    FILE    *rv;
    rv = fopen(str,"wb");
    if (rv == NULL) { perror(str); exit(1); }
    return rv;
}

void use_library(char* name)
{
    static int  cnt = 0;
    if (name) {
        Lib = ALLOC(cnt+2,Lib,char*);
        Lib[cnt++] = name;
        Lib[cnt] = NULL;
    }
}