gcanvas.c

Graphviz - Graph Drawing Programs from AT&T Research and Lucent Bell Labs See doc/build.html for

	gr.c.y = max(gr.c.y, gpp[i].y);
    }

    Gppi = 1;
    if (Gppi >= Gppn) {
	n = (((Gppi + 1) + PPINCR - 1) / PPINCR) * PPINCR;
	Gppp = Marraygrow(Gppp, (long) n * PPSIZE);
	Gppn = n;
    }
    Gppp[0] = p3 = pdrawtopix(widget, gpp[0]);
    for (i = 1; i < gpn; i += 3) {
	p0 = p3;
	p1 = pdrawtopix(widget, gpp[i]);
	p2 = pdrawtopix(widget, gpp[i + 1]);
	p3 = pdrawtopix(widget, gpp[i + 2]);
	bezier(p0, p1, p2, p3);
    }
    setgattr(widget, ap);
    gdk_draw_lines(widget->w->window, GC, Gppp, Gppi);
    return 0;
}


int GCarc(Gwidget_t * widget, Gpoint_t gc, Gsize_t gs, double ang1,
	  double ang2, Ggattr_t * ap)
{

    PIXpoint_t pc;
    PIXsize_t ps;
    Grect_t gr;

    gr.o.x = gc.x - gs.x, gr.o.y = gc.y - gs.y;
    gr.c.x = gc.x + gs.x, gr.c.y = gc.y + gs.y;
/*	if(!ISVISIBLE(gr))
		return 1;
*/

    pc = pdrawtopix(widget, gc), ps = sdrawtopix(widget, gs);
    setgattr(widget, ap);

    if (WCU->gattr.fill) {
	gdk_draw_arc(widget->w->window, GC, TRUE, pc.x - ps.x, pc.y - ps.y,
		     ps.x * 2, ps.y * 2, (int) (ang1 * 64), (ang2 * 64));
    } else {
	gdk_draw_arc(widget->w->window, GC, FALSE, pc.x - ps.x,
		     pc.y - ps.y, ps.x * 2, ps.y * 2, (int) (ang1 * 64),
		     (ang2 * 64));
    }
    return 0;
}


static GdkFont *findfont(char *name, int size)
{
    GdkFont *font;
    int fi, n, i;

    if (name[0] == '\000')
	return Gfontp[0].font;

    sprintf(&Gbufp[0], name, size);
    for (fi = 0; fi < Gfontn; fi++)
	if (Strcmp(&Gbufp[0], Gfontp[fi].name) == 0)
	    return Gfontp[fi].font;

    if (!(font = gdk_font_load(&Gbufp[0]))) {
	n = strlen(&Gbufp[0]) + 1;
	for (i = 1; i < size; i++) {
	    sprintf(&Gbufp[n], name, size - i);
	    if ((font = gdk_font_load(&Gbufp[n])))
		break;
	    sprintf(&Gbufp[n], name, size + i);
	    if ((font = gdk_font_load(&Gbufp[n])))
		break;
	}
    }
    if (!font)
	font = Gfontp[0].font;

    Gfontp = Marraygrow(Gfontp, (long) (Gfontn + 1) * FONTSIZE);
    Gfontp[Gfontn].name = strdup(&Gbufp[0]);
    Gfontp[Gfontn].font = font;
    Gfontn++;
    return font;
}


int GCtext(Gwidget_t * widget, Gtextline_t * tlp, int n, Gpoint_t go,
	   char *fn, double fs, char *justs, Ggattr_t * ap)
{

    Gsize_t gs;
    PIXpoint_t po;
    PIXsize_t ps;
    PIXrect_t pr;
    Grect_t gr;
    GdkFont *font;
    int dir, asc, des, x = 0, y, w, h, i;
    int lbearing, rbearing, width;

    po = pdrawtopix(widget, go);
    gs.x = 0, gs.y = fs;
    ps = sdrawtopix(widget, gs);
    if (!(font = findfont(fn, ps.y))) {
	printf("NO FONT\n");
	gdk_draw_rectangle(widget->w, GC, FALSE, po.x, po.y, 1, 1);
	return 0;
    }

    setgattr(widget, ap);
    SETFONT(font);

    for (w = h = 0, i = 0; i < n; i++) {
	gdk_text_extents(font, tlp[i].p, tlp[i].n, &lbearing, &rbearing,
			 &width, &asc, &des);

	tlp[i].w = width, tlp[i].h = asc + des;
	w = max(w, width), h += asc + des;

    }

    switch (justs[0]) {
    case 'l':
	po.x += w / 2;
	break;
    case 'r':
	po.x -= w / 2;
	break;
    }
    switch (justs[1]) {
    case 'd':
	po.y -= h;
	break;
    case 'c':
	po.y -= h / 2;
	break;
    }
    pr.o.x = po.x - w / 2, pr.o.y = po.y;
    pr.c.x = po.x + w / 2, pr.c.y = po.y + h;
    gr = rpixtodraw(widget, pr);

/*	if(!ISVISIBLE(gr))
		return 1;
*/

    for (i = 0; i < n; i++) {
	switch (tlp[i].j) {
	case 'l':
	    x = po.x - w / 2;
	    break;
	case 'n':
	    x = po.x - tlp[i].w / 2;
	    break;
	case 'r':
	    x = po.x - (tlp[i].w - w / 2);
	    break;
	}
	y = po.y + (i + 1) * tlp[i].h - des;

	gdk_draw_text(widget->w->window, font, GC, x, y, tlp[i].p,
		      tlp[i].n);
    }

    return 0;
}


int GCgettextsize(Gwidget_t * widget, Gtextline_t * tlp, int n, char *fn,
		  double fs, Gsize_t * gsp)
{

    Gsize_t gs;
    PIXsize_t ps;
    GdkFont *font;
    int i, dir, asc, des, rbearing, lbearing, width;

    gs.x = 0, gs.y = fs;
    ps = sdrawtopix(widget, gs);
    if (!(font = findfont(fn, ps.y))) {
	gsp->x = 1, gsp->y = 1;
	return 0;
    }
    SETFONT(font);
    for (ps.x = ps.y = 0, i = 0; i < n; i++) {
	gdk_text_extents(font, tlp[i].p, tlp[i].n, &lbearing, &rbearing,
			 &width, &asc, &des);
	ps.x = max(ps.x, width), ps.y += asc + des;
    }

    *gsp = spixtodraw(widget, ps);
    return 0;
}


int GCcreatebitmap(Gwidget_t * widget, Gbitmap_t * bitmap, Gsize_t s)
{

    return 0;
}


int GCdestroybitmap(Gbitmap_t * bitmap)
{

    return 0;
}


int GCreadbitmap(Gwidget_t * widget, Gbitmap_t * bitmap, FILE * fp)
{

    return 0;
}


int GCwritebitmap(Gbitmap_t * bitmap, FILE * fp)
{

    return 0;
}


int GCbitblt(Gwidget_t * widget, Gpoint_t gp, Grect_t gr,
	     Gbitmap_t * bitmap, char *mode, Ggattr_t * ap)
{
}


int GCgetmousecoords(Gwidget_t * widget, Gpoint_t * gpp, int *count)
{
    PIXpoint_t pp;
    int state;

    gdk_window_get_pointer(widget->w->window, &pp.x, &pp.y, &state);
    *gpp = Gppixtodraw(widget, pp);
    *count = 1;

    return 0;
}


int GCcanvasclear(Gwidget_t * widget)
{
    int gotit;
    GdkDrawable *drawable;
    GtkWidget *drawing_area = widget->w;
    drawable = drawing_area->window;

    gdk_window_clear(widget->w->window);
    gdk_draw_rectangle(drawable, drawing_area->style->white_gc, TRUE, 0, 0,
		       drawing_area->allocation.width,
		       drawing_area->allocation.height);
    WCU->needredraw = FALSE;
    gotit = FALSE;


    if (gotit)
	adjustclip(widget);
    return 0;
}


int GCgetgfxattr(Gwidget_t * widget, Ggattr_t * ap)
{

    if ((ap->flags & G_GATTRCOLOR))
	ap->color = WCU->gattr.color;
    if ((ap->flags & G_GATTRWIDTH))
	ap->width = WCU->gattr.width;
    if ((ap->flags & G_GATTRMODE))
	ap->mode = WCU->gattr.mode;
    if ((ap->flags & G_GATTRFILL))
	ap->fill = WCU->gattr.fill;
    if ((ap->flags & G_GATTRSTYLE))
	ap->style = WCU->gattr.style;
    return 0;
}


gint Gcwbutaction(GtkWidget * w, GdkEvent * event, gpointer data)
{
    Gwidget_t *widget;
    Gevent_t gev;
    int xtype, bn, wi;
    PIXpoint_t pp;

    widget = findwidget((unsigned long) w, G_CANVASWIDGET);
    switch ((xtype = event->type)) {
    case GDK_BUTTON_PRESS:
    case GDK_2BUTTON_PRESS:
    case GDK_3BUTTON_PRESS:
    case GDK_BUTTON_RELEASE:

	gev.type = G_MOUSE;
	gev.code = (xtype == GDK_BUTTON_PRESS) ? G_DOWN : G_UP;

	gev.data = event->button.button - 1;
	pp.x = event->button.x, pp.y = event->button.y;
	gev.p = Gppixtodraw(widget, pp);
	bn = WCU->bstate[gev.data];
	WCU->bstate[gev.data] = (xtype == GDK_BUTTON_PRESS) ? 1 : 0;
	bn = WCU->bstate[gev.data] - bn;
	WCU->buttonsdown += bn;
	Gbuttonsdown += bn;
	break;
    default:
	break;
    }

    wi = gev.wi = widget - &Gwidgets[0];
    Gpopdownflag = FALSE;
    if (WCU->func) {
	(*WCU->func) (&gev);
    }

    if (Gpopdownflag) {
	Gpopdownflag = FALSE;
	if (gev.code == G_DOWN) {

	    gev.code = G_UP;
	    widget = &Gwidgets[wi];
	    WCU->bstate[gev.data] = 0;
	    WCU->buttonsdown--;
	    Gbuttonsdown--;
	    if (widget->inuse && WCU->func)
		(*WCU->func) (&gev);
	}
    }
    return TRUE;
}


void Gcwkeyaction(GtkWidget * w, GdkEventKey * event, gpointer data)
{
    Gwidget_t *widget;
    Gevent_t gev;
    int xtype, bn, wi, state;
    PIXpoint_t pp;
    unsigned int mask;
    char c;

    widget = findwidget((unsigned long) canvas->w, G_CANVASWIDGET);
    switch ((xtype = event->type)) {
    case GDK_KEY_PRESS:
    case GDK_KEY_RELEASE:
	gdk_window_get_pointer(event->window, &pp.x, &pp.y, &state);
	gev.type = G_KEYBD;
	gev.code = (xtype == GDK_KEY_PRESS) ? G_DOWN : G_UP;
	gev.data = event->keyval;
	gev.p = Gppixtodraw(widget, pp);
	break;
    default:
	return;
    }
    gev.wi = widget - &Gwidgets[0];
    Gpopdownflag = FALSE;
    if (WCU->func)
	(*WCU->func) (&gev);
    if (Gpopdownflag)
	Gpopdownflag = FALSE;

}


gint exposeeventhandler(GtkWidget * w, GdkEvent * event, gpointer data)
{
    Gwidget_t *widget;

    widget = findwidget((unsigned long) w, G_CANVASWIDGET);
    gdk_draw_rectangle(widget->w->window, widget->w->style->white_gc, TRUE,
		       0, 0, widget->w->allocation.width,
		       widget->w->allocation.height);
}


gint cweventhandler(GtkWidget * w, GdkEvent * event, gpointer data)
{
    Gwidget_t *widget;

    widget = findwidget((unsigned long) w, G_CANVASWIDGET);
    Gneedredraw = WCU->needredraw = TRUE;
    adjustclip(widget);

    gtk_signal_connect(G_OBJECT(w), "visibility_notify_event",
		       GTK_SIGNAL_FUNC(cweventhandler), NULL);
    gtk_signal_connect(G_OBJECT(w), "motion_notify_event",
		       GTK_SIGNAL_FUNC(cweventhandler), NULL);
}


static void setgattr(Gwidget_t * widget, Ggattr_t * ap)
{
    GdkGCValues gcv;
    GdkColor c;
    int color, width, mode, style, pati;
    double intens;

    if (!(ap->flags & G_GATTRCOLOR))
	ap->color = WCU->defgattr.color;
    if (!(ap->flags & G_GATTRWIDTH))
	ap->width = WCU->defgattr.width;
    if (!(ap->flags & G_GATTRMODE))
	ap->mode = WCU->defgattr.mode;
    if (!(ap->flags & G_GATTRFILL))
	ap->fill = WCU->defgattr.fill;
    if (!(ap->flags & G_GATTRSTYLE))
	ap->style = WCU->defgattr.style;
    color = ap->color;

    if (color >= G_MAXCOLORS || !(WCU->colors[color].inuse))
	color = 1;

    if (color != WCU->gattr.color) {

	WCU->gattr.color = color;
	/*if (ap->mode == GDK_XOR) {
	   gdk_gc_set_foreground (GC, widget->w->style->white_gc);
	   }
	   else {
	 */
	gdk_gc_set_foreground(GC, &WCU->colors[WCU->gattr.color].color);
	/* } */

/*	    if (Gdepth == 1) {
	        cp = &WCU->colors[color].color;
	        intens = (0.3 * cp->blue + 0.59 * cp->red +
	                        0.11 * cp->green) / 65535.0;
	        pati = (intens <= 0.0625) ? 16 :
	                    -16.0 * (log (intens) / 2.7725887222);
	        XSetTile (Gdisplay, GC, WCU->grays[pati]);
            }
*/
    }
    mode = ap->mode;
    if (mode != WCU->gattr.mode) {
	WCU->gattr.mode = mode;
/*	    XSetFunction (Gdisplay, GC, WCU->gattr.mode);
	    if (mode == GDK_XOR)
            	gdk_gc_set_foreground (GC, &WCU->colors[0].color);
            else
*/
	gdk_gc_set_foreground(GC, &WCU->colors[WCU->gattr.color].color);
    }
    width = ap->width;
    if (width != WCU->gattr.width) {
	gdk_gc_set_line_attributes(GC, width, GDK_LINE_SOLID,
				   GDK_CAP_NOT_LAST, GDK_JOIN_BEVEL);
    }

    WCU->gattr.fill = ap->fill;
    style = ap->style;
    if (style != WCU->gattr.style) {
	WCU->gattr.style = style;
	if (style == G_SOLID) {
	    gdk_gc_set_line_attributes(GC, width, GDK_LINE_SOLID,
				       GDK_CAP_NOT_LAST, GDK_JOIN_BEVEL);
	} else {
	    gdk_gc_set_dashes(GC, 0, gstyles[style], 2);
	    gdk_gc_set_line_attributes(GC, width, GDK_LINE_ON_OFF_DASH,
				       GDK_CAP_NOT_LAST, GDK_JOIN_BEVEL);
	}
    }
}


static PIXrect_t rdrawtopix(Gwidget_t * widget, Grect_t gr)
{
    PIXrect_t pr;
    double tvx, tvy, twx, twy;

    tvx = WCU->vsize.x - 1, tvy = WCU->vsize.y - 1;
    twx = WCU->wrect.c.x - WCU->wrect.o.x;
    twy = WCU->wrect.c.y - WCU->wrect.o.y;
    pr.o.x = tvx * (gr.o.x - WCU->wrect.o.x) / twx + 0.5;
    pr.o.y = tvy * (1.0 - (gr.c.y - WCU->wrect.o.y) / twy) + 0.5;
    pr.c.x = tvx * (gr.c.x - WCU->wrect.o.x) / twx + 0.5;
    pr.c.y = tvy * (1.0 - (gr.o.y - WCU->wrect.o.y) / twy) + 0.5;
    return pr;
}


static PIXpoint_t pdrawtopix(Gwidget_t * widget, Gpoint_t gp)
{
    PIXpoint_t pp;
    double tvx, tvy, twx, twy;

    tvx = WCU->vsize.x - 1, tvy = WCU->vsize.y - 1;
    twx = WCU->wrect.c.x - WCU->wrect.o.x;
    twy = WCU->wrect.c.y - WCU->wrect.o.y;

    pp.x = tvx * (gp.x - WCU->wrect.o.x) / twx + 0.5;
    pp.y = tvy * (1.0 - (gp.y - WCU->wrect.o.y) / twy) + 0.5;
    return pp;
}


static PIXsize_t sdrawtopix(Gwidget_t * widget, Gsize_t gs)
{
    PIXsize_t ps;
    double tvx, tvy, twx, twy;

    tvx = WCU->vsize.x - 1, tvy = WCU->vsize.y - 1;
    twx = WCU->wrect.c.x - WCU->wrect.o.x;
    twy = WCU->wrect.c.y - WCU->wrect.o.y;
    ps.x = tvx * (gs.x - 1) / twx + 1.5;
    ps.y = tvy * (gs.y - 1) / twy + 1.5;

    return ps;
}


static Gpoint_t Gppixtodraw(Gwidget_t * widget, PIXpoint_t pp)
{
    Gpoint_t gp;
    double tvx, tvy, twx, twy;

    tvx = WCU->vsize.x - 1, tvy = WCU->vsize.y - 1;
    twx = WCU->wrect.c.x - WCU->wrect.o.x;
    twy = WCU->wrect.c.y - WCU->wrect.o.y;

    gp.x = (pp.x / tvx) * twx + WCU->wrect.o.x;
    gp.y = (1.0 - pp.y / tvy) * twy + WCU->wrect.o.y;
    return gp;
}


static Gsize_t spixtodraw(Gwidget_t * widget, PIXsize_t ps)
{
    Gsize_t gs;
    double tvx, tvy, twx, twy;

    tvx = WCU->vsize.x - 1, tvy = WCU->vsize.y - 1;
    twx = WCU->wrect.c.x - WCU->wrect.o.x;
    twy = WCU->wrect.c.y - WCU->wrect.o.y;
    gs.x = ((ps.x - 1) / tvx) * twx + 1;
    gs.y = ((ps.y - 1) / tvy) * twy + 1;
    return gs;
}


static Grect_t rpixtodraw(Gwidget_t * widget, PIXrect_t pr)
{
    Grect_t gr;
    double tvx, tvy, twx, twy, n;

    tvx = WCU->vsize.x - 1, tvy = WCU->vsize.y - 1;
    twx = WCU->wrect.c.x - WCU->wrect.o.x;
    twy = WCU->wrect.c.y - WCU->wrect.o.y;

    gr.o.x = (pr.o.x / tvx) * twx + WCU->wrect.o.x;
    gr.o.y = (1.0 - pr.c.y / tvy) * twy + WCU->wrect.o.y;
    gr.c.x = (pr.c.x / tvx) * twx + WCU->wrect.o.x;
    gr.c.y = (1.0 - pr.o.y / tvy) * twy + WCU->wrect.o.y;

    if (gr.o.x > gr.c.x)
	n = gr.o.x, gr.o.x = gr.c.x, gr.c.x = n;
    if (gr.o.y > gr.c.y)
	n = gr.o.y, gr.o.y = gr.c.y, gr.c.y = n;
    return gr;
}


static PIXrect_t rdrawtobpix(Gbitmap_t * bitmap, Grect_t gr)
{
    PIXrect_t pr;
    double tvy;

    tvy = (bitmap->size.y - 1) * bitmap->scale.y;
    pr.o.x = gr.o.x + 0.5;
    pr.o.y = tvy - gr.c.y + 0.5;
    pr.c.x = gr.c.x + 0.5;
    pr.c.y = tvy - gr.o.y + 0.5;
    return pr;
}


static PIXpoint_t pdrawtobpix(Gbitmap_t * bitmap, Gpoint_t gp)
{
    PIXpoint_t pp;
    double tvy;

    tvy = (bitmap->size.y - 1) * bitmap->scale.y;
    pp.x = gp.x + 0.5;
    pp.y = tvy - gp.y + 0.5;
    return pp;
}


static void adjustclip(Gwidget_t * widget)
{
    Gwidget_t *parent;
    PIXrect_t pr;
    int width, height;

}